C#: Interfaces to Functions, With FuncR

FuncR is a small .NET standard library that enables you to register functions against interfaces in C#.

In short, it allows you to go from this:

Into something like this:

FuncR uses a DispatchProxy to generate a proxy class that instantiates the interface at runtime and hooks up the registered functions to the interface methods.

This allows you to inject the interface into your services and use it like any other service in your domain.

Let’s put this all together inside a .NET console app!

Create a new Console app (in .NET Core 2, 3 or .NET 5):

mkdir Your.First.Function
cd Your.First.Function
dotnet new console

Add the FuncR package:

dotnet add package FuncR

Write the implementation:

using System;
using FuncR;
using Microsoft.Extensions.DependencyInjection;

namespace Your.First.Function
{
    // We don't need no, implementation
    public interface IFooService    
    {
        string Foo (int numberOfFoos);    
    }
    
    class Program    
    {
        static void Main(string[] args)        
        {
            var services = new ServiceCollection();
            
            services.AddScopedFunction<IFooService>                
                (nameof(IFooService.Foo))
                // string Foo(int numberOfFoos)                
                .Runs<int, string>(numberOfFoos=>                
                {
                    if(numberOfFoos>=5)
                        return "Too many foos!";
                    
                    return $"This many foos: '{numberOfFoos}'";                
                });
             
             var fooService=
                services.BuildServiceProvider()
                .GetRequiredService<IFooService>();
             // Prints: "This many foos: '3'"
             Console.WriteLine(fooService.Foo(3));
             // Prints: "Too many foos!"
             Console.WriteLine(fooService.Foo(5));        
     }   
}}