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)
	{
		//Code here...
	}
	
	public void Add(Item item)
	{
		//Code here...
	}
}

public void ConfigureServices(IServiceCollection services)
{
	services
		.AddJsonRpc(config =>
		{
			//(Optional) Hard cap on batch size, will block requests will larger sizes, defaults to no limit
			config.BatchRequestLimit = 5;
			//(Optional) If true returns full error messages in response, defaults to false
			config.ShowServerExceptions = false;
			//(Optional) Configure how the router serializes requests
			config.JsonSerializerSettings = new System.Text.Json.JsonSerializerOptions
			{
				//Example json config
				IgnoreNullValues = false,
				WriteIndented = true
			};
			//(Optional) Configure custom exception handling for exceptions during invocation of the method
			config.OnInvokeException = (context) =>
			{
				if (context.Exception is InvalidOperationException)
				{
					//Handle a certain type of exception and return a custom response instead
					//of an internal server error
					int customErrorCode = 1;
					var customData = new
					{
						Field = "Value"
					};
					var response = new RpcMethodErrorResult(customErrorCode, "Custom message", customData);
					return OnExceptionResult.UseObjectResponse(response);
				}
				//Continue to throw the exception
				return OnExceptionResult.DontHandle();
			};
		});
		});
}

public void Configure(IApplicationBuilder app)
{
    //This will register all the classes that derive from `RpcController` and their public instance methods
	app.UseJsonRpc();
}

public void Configure(IApplicationBuilder app)
{
    //This will register all the classes that derive from `ControllerBase` and their public instance methods
    //E.g. `ControllerBase` has 3 child classes/controllers (CustomController, OtherController, Commands) so by default 
	//three routes would be `Custom`, `Other` and `Commands` respectively, but since CustomController is decorated with RpcRouteAttribute("Main"),
	//its route will be `Main` instead of `Custom`
	app.UseJsonRpcWithBaseController<ControllerBase>();
}

public void Configure(IApplicationBuilder app)
{
	app.UseJsonRpc(options =>
    {
    	options
    		//Will make controller methods available for path '/First', unless overridden by RpcRouteAttribute
    		//Note that any class will work here, not just a class derived from `RpcController`
    		.AddController<NonRpcController>()
    		//Will make controller methods available for custom path '/CustomPath'
    		//Note that the same controller can be available under multiple routes
    		.AddControllerWithCustomPath<NonRpcController>("CustomPath");
    });
}

public void Configure(IApplicationBuilder app)
{
	app.UseJsonRpc(options =>
    {
		MethodInfo customControllerMethod1 = typeof(CustomController).GetMethod("Method1");
		MethodInfo otherControllerMethod1 = typeof(OtherController).GetMethod("Method1");
		options
			//Will make the `Method1` method in `CustomController` available with route '/'
			//Note that since that method has `RpcRouteAttribute("Method")`, that will change the method name
			//from `Method1` to `Method` in the router
			.AddMethod(customControllerMethod1)
			//Will make the `Method1` method in `OtherController` available with route '/CustomMethods'
			.AddMethod(otherControllerMethod1, "CustomMethods");
    });
}

[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;
	}
}