| | | 1 | | using System.Diagnostics.CodeAnalysis; |
| | | 2 | | using System.Linq.Expressions; |
| | | 3 | | using System.Reflection; |
| | | 4 | | |
| | | 5 | | namespace AsyncResponse; |
| | | 6 | | |
| | | 7 | | /// <summary> |
| | | 8 | | /// Converts strongly-typed lambda expressions into serializable <see cref="ReflectionCallDto"/>s. |
| | | 9 | | /// Literal arguments are evaluated and captured by value; <see cref="Placeholder"/> marker calls |
| | | 10 | | /// become runtime placeholders. This gives compile-time safety (rename-refactoring, type checks) |
| | | 11 | | /// over hand-written reflection descriptors. |
| | | 12 | | /// </summary> |
| | | 13 | | internal static class CallbackExpressionConverter |
| | | 14 | | { |
| | | 15 | | /// <summary>Converts the callback expression to a reflection call descriptor.</summary> |
| | | 16 | | public static ReflectionCallDto ToReflectionCall<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMe |
| | 2 | 17 | | => Build<TService>(expression.Body); |
| | | 18 | | |
| | | 19 | | /// <summary>Converts the callback expression to a reflection call descriptor.</summary> |
| | | 20 | | public static ReflectionCallDto ToReflectionCall<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMe |
| | 9322 | 21 | | => Build<TService>(expression.Body); |
| | | 22 | | |
| | | 23 | | /// <summary>Converts the callback expression to a reflection call descriptor.</summary> |
| | | 24 | | public static ReflectionCallDto ToReflectionCall<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMe |
| | 2 | 25 | | => Build<TService>(expression.Body); |
| | | 26 | | |
| | | 27 | | private static ReflectionCallDto Build<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] TS |
| | | 28 | | { |
| | 9326 | 29 | | if (body is not MethodCallExpression call) |
| | 2 | 30 | | throw new NotSupportedException($"Only direct method calls are supported. Got: {body.NodeType}"); |
| | | 31 | | |
| | | 32 | | // instance call on the lambda parameter (svc => svc.Method(...)) |
| | 9324 | 33 | | if (call.Object is not ParameterExpression svcParam || svcParam.Type != typeof(TService)) |
| | 2 | 34 | | throw new NotSupportedException("Lambda must be like: svc => svc.YourMethod(args)"); |
| | | 35 | | |
| | 24489 | 36 | | var args = call.Arguments.Select(arg => ConvertArgument(arg, svcParam)).ToArray(); |
| | | 37 | | |
| | | 38 | | // The compiler resolved `call.Method` from full signatures, but the descriptor persists only |
| | | 39 | | // its NAME and ARITY — the wire contract every deployment reading it shares. Validate here, |
| | | 40 | | // where the caller's stack is, that name + arity still select exactly this one method (no |
| | | 41 | | // overload set sharing both, no by-ref or open-generic parameters). Without this an |
| | | 42 | | // interface such as `Run(int)` / `Run(string)` accepted `svc => svc.Run(1)` and every |
| | | 43 | | // dispatch of the job then failed as ambiguous — after publication, on a worker, burning |
| | | 44 | | // the transport's retries or stranding a recovery registration. |
| | 9318 | 45 | | ReflectionExtensions.EnsureBindable(typeof(TService), call.Method.Name, args.Length); |
| | | 46 | | |
| | 9312 | 47 | | return new ReflectionCallDto |
| | 9312 | 48 | | { |
| | 9312 | 49 | | ServiceInterfaceFullName = typeof(TService).FullName |
| | 9312 | 50 | | ?? throw new InvalidOperationException("Service interface must have FullName."), |
| | 9312 | 51 | | MethodName = call.Method.Name, |
| | 9312 | 52 | | Params = args |
| | 9312 | 53 | | }; |
| | | 54 | | } |
| | | 55 | | |
| | | 56 | | private static CallbackParam ConvertArgument(Expression expression, ParameterExpression svcParam) |
| | | 57 | | { |
| | | 58 | | // A generic payload passed to an object parameter is wrapped in an implicit Convert node. |
| | | 59 | | // Strip only that harmless boxing/reference conversion so the marker remains top-level. |
| | 15167 | 60 | | if (expression is UnaryExpression { NodeType: ExpressionType.Convert or ExpressionType.ConvertChecked } conversi |
| | 15167 | 61 | | && conversion.Method is null |
| | 15167 | 62 | | && conversion.Type.IsAssignableFrom(conversion.Operand.Type)) |
| | 1491 | 63 | | expression = conversion.Operand; |
| | | 64 | | |
| | | 65 | | // Placeholder.Payload<T>() / Placeholder.Exception() / Placeholder.CorrelationId() |
| | | 66 | | // used directly as an argument become runtime placeholders. |
| | 15167 | 67 | | if (expression is MethodCallExpression marker && marker.Method.DeclaringType == typeof(Placeholder)) |
| | | 68 | | { |
| | 6014 | 69 | | return marker.Method.Name switch |
| | 6014 | 70 | | { |
| | 1513 | 71 | | nameof(Placeholder.Payload) => CallbackParam.ForPlaceholder(PlaceholderType.Payload), |
| | 1499 | 72 | | nameof(Placeholder.Exception) => CallbackParam.ForPlaceholder(PlaceholderType.Exception), |
| | 3002 | 73 | | nameof(Placeholder.CorrelationId) => CallbackParam.ForPlaceholder(PlaceholderType.CorrelationId), |
| | 0 | 74 | | _ => throw new NotSupportedException($"Unknown placeholder marker '{marker.Method.Name}'.") |
| | 6014 | 75 | | }; |
| | | 76 | | } |
| | | 77 | | |
| | 9153 | 78 | | return CallbackParam.ForValue(EvaluateArgument(expression, svcParam)); |
| | | 79 | | } |
| | | 80 | | |
| | | 81 | | // Evaluate each argument expression as a closed lambda. Disallow: |
| | | 82 | | // - method calls inside args (conservative; placeholders are handled above) |
| | | 83 | | // - any reference to the svc parameter |
| | | 84 | | private static object? EvaluateArgument(Expression expression, ParameterExpression svcParam) |
| | | 85 | | { |
| | 9153 | 86 | | if (ContainsMethodCall(expression)) |
| | 2 | 87 | | throw new NotSupportedException( |
| | 2 | 88 | | "Arguments must be constants/new/array/member access, or a top-level Placeholder marker; " + |
| | 2 | 89 | | "other method-call arguments are not allowed."); |
| | | 90 | | |
| | 9151 | 91 | | if (ReferencesParameter(expression, svcParam)) |
| | 2 | 92 | | throw new NotSupportedException("Argument must not reference the service parameter (e.g., svc => svc.M(svc.P |
| | | 93 | | |
| | 9149 | 94 | | if (expression is ConstantExpression constant) |
| | | 95 | | { |
| | 748 | 96 | | return constant.Value; |
| | | 97 | | } |
| | | 98 | | |
| | | 99 | | // The dominant non-constant shape is a C# closure capture — a field read off the |
| | | 100 | | // compiler's display class (a ConstantExpression), or a static field. Read it directly: |
| | | 101 | | // building and interpreting a lambda for it cost ~60x in time and allocations, per |
| | | 102 | | // argument, per enqueue. Fields cannot throw, so behavior is identical to the |
| | | 103 | | // interpreted read. Anything deeper (nested members, properties, new/array) falls |
| | | 104 | | // through to the interpreter below. |
| | 8401 | 105 | | if (expression is MemberExpression { Member: FieldInfo field } fieldAccess) |
| | | 106 | | { |
| | 8387 | 107 | | if (fieldAccess.Expression is ConstantExpression closure) |
| | 8373 | 108 | | return field.GetValue(closure.Value); |
| | | 109 | | |
| | 14 | 110 | | if (fieldAccess.Expression is null) |
| | 2 | 111 | | return field.GetValue(null); |
| | | 112 | | } |
| | | 113 | | |
| | | 114 | | // Use the interpreter to avoid JIT'ing lots of tiny dynamic methods, but keep the delegate |
| | | 115 | | // typed so argument capture does not pay DynamicInvoke's reflection dispatch cost. |
| | 26 | 116 | | var boxed = expression.Type == typeof(object) |
| | 26 | 117 | | ? expression |
| | 26 | 118 | | : Expression.Convert(expression, typeof(object)); |
| | 26 | 119 | | var lambda = Expression.Lambda<Func<object?>>(boxed); |
| | 26 | 120 | | return lambda.Compile(preferInterpretation: true)(); |
| | | 121 | | } |
| | | 122 | | |
| | | 123 | | private static bool ContainsMethodCall(Expression expression) |
| | | 124 | | { |
| | 9153 | 125 | | var visitor = new MethodCallGuard(); |
| | 9153 | 126 | | visitor.Visit(expression); |
| | 9153 | 127 | | return visitor.Found; |
| | | 128 | | } |
| | | 129 | | |
| | | 130 | | private static bool ReferencesParameter(Expression expression, ParameterExpression parameter) |
| | | 131 | | { |
| | 9151 | 132 | | var visitor = new ParameterGuard(parameter); |
| | 9151 | 133 | | visitor.Visit(expression); |
| | 9151 | 134 | | return visitor.Found; |
| | | 135 | | } |
| | | 136 | | |
| | | 137 | | private sealed class MethodCallGuard : ExpressionVisitor |
| | | 138 | | { |
| | | 139 | | public bool Found; |
| | | 140 | | |
| | | 141 | | /// <summary>Runs the Visit operation.</summary> |
| | | 142 | | public override Expression? Visit(Expression? node) |
| | | 143 | | { |
| | 17584 | 144 | | if (Found || node is null) return node; |
| | 17580 | 145 | | if (node.NodeType == ExpressionType.Call) { Found = true; return node; } |
| | 17574 | 146 | | return base.Visit(node); |
| | | 147 | | } |
| | | 148 | | } |
| | | 149 | | |
| | 9151 | 150 | | private sealed class ParameterGuard(ParameterExpression _parameter) : ExpressionVisitor |
| | | 151 | | { |
| | | 152 | | public bool Found; |
| | | 153 | | |
| | | 154 | | /// <summary>Runs the VisitParameter operation.</summary> |
| | | 155 | | protected override Expression VisitParameter(ParameterExpression node) |
| | | 156 | | { |
| | 4 | 157 | | if (node == _parameter) Found = true; |
| | 2 | 158 | | return base.VisitParameter(node); |
| | | 159 | | } |
| | | 160 | | } |
| | | 161 | | } |