Support for reusable expressions

[drjonnicholson]

Proposal

While APIM has fragments, which allows reusability between policies, I think having the ability to define policies through C# code provides some really great opportunities to offer an alternative way to "share functionality".

Specifically, I'm thinking in scenarios where the same "line of code" might be used in multiple places. For example, say I needed to get the caller's IP address and I'm behind an App Gateway. I might do something like this:

public static string GetOriginIp(IExpressionContext context) => context.Request.Headers.GetValueOrDefault("X-Forwarded-For", context.Request.IpAddress)

This might need to be used in a number of places such as for caching, rate limiting, telemetry, request logic, etc. I could use a fragment to do nothing but set a variable into the policy and retrieve that, but that feels really heavy handed and not really hat I think fragments are there for.

Since this toolkit allows the policy to be generated, there's less concern about repetition in the output. That is, I mind less if that above line of code appears multiple times as long as I know when it appears it's the version I've defined and it's been thoroughly tested.

So what would be fantastic is the ability to define simple static classes with expression methods in them. Those "helper" classes can then group together a load of common expression logic that might be reused, can be tested like any other expression methods, referred to in the way you'd expect in the C# code, and compile out to the same XML output as if the method were defined in the current compilation unit.

In theory, that would allow more flexibility in how a solution approaches code reuse - expressions can be externalised as well tested but repeatedly injected code, fragments are kept to reusable series of policies.

Component

Compiler

Contact Details

No response

[Mielek]

Hello @drjonnicholson ! Thank you for contributing this issue to the project!

Yes! This was exactly why I was changing the compilation to use .csproj file. Standard .net compilation with Roslyn produce data which would allow compiler to do inlining parts of code from different files. With that I could reach to other files and inline external to policy document fields and methods.

Reusable expressions and reusable parts of expressions are a good way to start. But I would not stop at expressions. I think even creating a reusable method with set of policies would be great to have. This would be another way of defining policy fragment, but it will give the user flexibility. User could choose then if they want to inline or create APIM policy fragment from them.

I believe, defining parts of expressions, parts of policies as reusable fragments are crucial for flexibility of implementation, code maintainability and testability.

[drjonnicholson]

Absolutely aligned!

I noticed between the released 1.0.0 and a build off main there was a change in the output mentioning csproj file, does this mean it's working on main branch as of now? (i'd only tried on the released 1.0.0 before I submitted the request)

[Mielek]

Main have posibility to load, compile code and compile policies. Main does not have the ability to do the reusable expressions.