dotnet add package EdjCase.JsonRpc.Router

Install-Package EdjCase.JsonRpc.Router

public void ConfigureServices(IServiceCollection services)
{
	services.AddJsonRpc();
}

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
	app.UseJsonRpc();
}

public class ItemsController : RpcController
{
	public Item Get(int id)
	{
		//Gets item with id
	}
	
	public void Add(Item item)
	{
		//Adds item
	}
}

public void ConfigureServices(IServiceCollection services)
{
 	services.AddJsonRpc(options =>
	{
		//(Optional) Hard cap on batch size, will block requests will larger sizes, defaults to no limit
		options.BatchRequestLimit = 5;
		//(Optional) If true returns full error messages in response, defaults to false
		options.ShowServerExceptions = false;
		//(Optional) Configure how the router serializes requests
		options.JsonSerializerSettings = new Newtonsoft.Json.JsonSerializerSettings
		{
			//Example json config
			NullValueHandling = Newtonsoft.Json.NullValueHandling.Include,
			Formatting = Newtonsoft.Json.Formatting.Indented,
			DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Include
		};
	});	
}

public void Configure(IApplicationBuilder app)
{
	app
		//(Optional) Adding authentication (need to add AddAuthentication() in the `ConfigureServices` method)
		.UseAuthentication()
		.UseJsonRpc(options =>
		{
			//(Optional) Overriding base class for all rpc controllers to be detected from, defaults to `RpcController`
			options.BaseControllerType = typeof(MyCustomControllerBase);
			//(Optional) Overring base url, defaults to "/" ("/Items" would now be "/api/Items")
			options.BaseRequestPath = "/api";
		});
}

public void Configure(IApplicationBuilder app)
{
	app
		//(Optional) Adding authentication (need to add AddAuthentication() in the `ConfigureServices` method)
		.UseAuthentication()
		.UseManualJsonRpc(builder =>
		{
			//Maps `Class1` and its public methods to '/' route
			builder.RegisterController<Class1>();
			//Also maps `Class2` and its public methods to '/' route, along side with `Class1` (methods will collide)
			builder.RegisterController<Class2>();
			//Maps `Class3` and its public methods to '/Items' route
			builder.RegisterController<Class3>("Items");
			//Maps `Class1` and its public methods to '/Items/Books' route
			builder.RegisterController<Class4>("Items/Books");
		});
}

public void Configure(IApplicationBuilder app)
{
	//Custom route provider (specified below)
	IRpcRouteProvider routeProvider = new MyRouteProvider();
	app
		//(Optional) Adding authentication (need to add AddAuthentication() in the `ConfigureServices` method)
		.UseAuthentication()
		//Specify custom route provider
		.UseJsonRpc(routeProvider);
}

public class MyRouteProvider : IRpcRouteProvider
{
	//Base url route
	public RpcPath BaseRequestPath { get; } = "/api";

	//Return method providers per url route (does not include base route)
	public List<IRpcMethodProvider> GetMethodsByPath(RpcPath path)
	{
		if (path == "/Items")
		{
			return new List<IRpcMethodProvider>
			{
				new ItemsMethodProvider()
			};
		}
		else if(path == "/Things")
		{
			return new List<IRpcMethodProvider>
			{
				new ThingsMethodProvider()
			};
		}
		else
		{
			return new List<IRpcMethodProvider>();
		}
	}

	//Set of all possible routes
	public HashSet<RpcPath> GetRoutes()
	{
		return new HashSet<RpcPath>
		{
			"/Items",
			"/Things"
		};
	}
}

//Method provider for items controller
public class ItemsMethodProvider : IRpcMethodProvider
{
	public List<MethodInfo> GetRouteMethods()
	{
		//Reflection to get all public and instanced methods
		return typeof(ItemsController).GetTypeInfo()
			.GetMethods(BindingFlags.Public | BindingFlags.Instance)
			.ToList();
	}
}

//Method provider for things controller
public class ThingsMethodProvider : IRpcMethodProvider
{
	public List<MethodInfo> GetRouteMethods()
	{
		//Reflection to get all public and instanced methods
		return typeof(ThingsController).GetTypeInfo()
			.GetMethods(BindingFlags.Public | BindingFlags.Instance)
			.ToList();
	}
}

[RpcRoute("TestMethods")] //Optional, if not specified the route name would be 'Test' (based off the controller type name)
public class TestController : RpcController
{
	//Will return a success response or an error response dependening on the if statement
	// (See IRpcMethodResult usage below)
	public IRpcMethodResult CustomResult()
	{
		if(/*something is invalid*/)
		{
			return this.Error(customErrorCode, errorMesssage); //Or return new RpcMethodErrorResult(customErrorCode, errorMessage);
		}
		return this.Ok(optionalReturnObject);//Or return new RpcMethodSuccessResult(optionalReturnObject);
	}
	
	//Returning values is also valid but will never give an error unless an exception is thrown
	public int Subtract(int a, int b)
	{
		return a - b;
	}    
	
	//Accessable to api at /{OptionalRoutePrefix}/{OptionalRoute}/Add 
	//e.g. (from previous example) /RpcApi/Add or /RpcApi/Class2/Add
	//Example request using param list: {"jsonrpc": "2.0", "id": 1, "method": "Add", "params": [1,2]}
	//Example request using param map: {"jsonrpc": "2.0", "id": 1, "method": "Add", "params": {"a": 1, "b": 2}}
	//Example response from a=1, b=2: {"jsonrpc", "2.0", "id": 1, "result": 3}
	public int Add(int a, int b)
	{
		return a + b;
	}
	
	//This method would use the same request as Add(int a, int b) (except method would be 'AddAsync') 
	//and would respond with the same response
	public async Task<int> AddAsync(int a, int b)
	{
		//async adding here
	}
	
	//Can't be called/will return MethodNotFound because it is private. Same with all non-public/static methods.
	private void Hidden1()
	{
	}
}

//Classes can be named anything and be located anywhere in the project/solution
//The way to associate them to the api is to use the RegisterController<T> method in
//the configuration
public class RpcClass1
{
	public int Add(int a, int b)
	{
		return a + b;
	}
}