C# functions with multiple fat arrows

Question

I am having a hard time wrapping my head around this function with multiple fat arrows.

services.AddTransient<ServiceA>();
services.AddTransient<ServiceB>();
services.AddTransient<ServiceC>();

services.AddTransient<ServiceResolver>(serviceProvider => key =>
{
    switch (key)
    {
        case "A":
            return serviceProvider.GetService<ServiceA>();
        case "B":
            return serviceProvider.GetService<ServiceB>();
        case "C":
            return serviceProvider.GetService<ServiceC>();
        default:
            throw new KeyNotFoundException(); // or maybe return null, up to you
    }
});

In C# i have never come across this function style serviceProvider => key =>. Can anyone please explain to me what it means

It's a new [switch expression](https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#switch-expressions) — Aarnihauta, Jan 25 '22 at 13:21
JS answer, same advice https://stackoverflow.com/a/37323357/1043380 — gunr2171, Jan 25 '22 at 13:22
usual nested lambda functions, _not_ the C# 8 switch expression — Anand Sowmithiran, Jan 25 '22 at 13:24
I am familiar with JS and in JS its called Higher Order Function. But i am not familiar with this in c# — jhon.smith, Jan 25 '22 at 13:24
This is a good example of how people are using lambda's -that were added to make the language more expressive- in a complex, not expressive way. But I guess that's [Hyrum's Law](https://www.hyrumslaw.com/) — JHBonarius, Jan 25 '22 at 13:26
@jhon.smith It's still a higher order function - the name is not JS specific — phuzi, Jan 25 '22 at 13:28
`=>` is commonly read as "goes to". See [How do I pronounce "=>" as used in lambda expressions in .Net](https://stackoverflow.com/q/274022/150605) and [C# Lambda ( => )](https://stackoverflow.com/q/3970219/150605) — Lance U. Matthews, Jan 26 '22 at 07:39

Guru Stron · Answer 1 · 2022-01-25T14:14:56.857

2

This is an lambda expression returning another lambda expression.

Not sure what is ServiceResolver but I would say that it is a delegate looking something like this:

// IService - shared contract for ServiceA, ServiceB, ...
public delegate IService ServiceResolver(string key);

Then the invocation services.AddTransient<ServiceResolver>(serviceProvider => ...) is a call to AddTransient method accepting a Func<T, TResult> delegate, which is constructed via lambda expression and returning another delegate constructed also via lambda expression (key => {...}).

edited Jan 25 '22 at 14:14

answered Jan 25 '22 at 13:31

Guru Stron

102,774
10
95
132

Yup, this is it exactly. though I would guess instead of `object` it is an interface that ServiceA, B and C implement. – DavidG Jan 25 '22 at 13:34
@DavidG yes, that what I was trying to reflect in the comment. – Guru Stron Jan 25 '22 at 13:35

Peter Csala · Accepted Answer · 2022-01-25T18:15:23.417

Yes indeed, it is a high-order function, so it's a function which returns another function.

Let's see the last AddTransient method call's parameter from inside out:

key =>
{
    switch (key)
    {
        case "A":
            return serviceProvider.GetService<ServiceA>();
        case "B":
            return serviceProvider.GetService<ServiceB>();
        case "C":
            return serviceProvider.GetService<ServiceC>();
        default:
            throw new KeyNotFoundException(); // or maybe return null, up to you
    }
};

You can describe this function as a Func<String, Object> if ServiceA ... ServiceC don't have any common ancestor / does not implement a common interface.

So you have a function which receives a string (key) and returns an object.

serviceProvider => key =>
{
    ...
}

This function can be described with Func<ServiceProvider, Func<String, Object>>. If this function receives a serviceProvider instance during its method call then it will return a function which anticipates a string and returns an object.

If you have a function like the above then you can call the inner via the outer:

Func<ServiceProvider, Func<String, Object>> factoryMethodRegister = ...
Func<String, Object> factoryMethod = factoryMethodRegister(sp);
Object instance = factoryMethod(key);

//OR
Func<ServiceProvider, Func<String, Object>> factoryMethodRegister = ...
Object instance = factoryMethodRegister(sp)(key);

wow Amazing break down of the subject and excellent explanation thanks — jhon.smith, Jan 25 '22 at 17:37

C# functions with multiple fat arrows

2 Answers2