API vocabulary: MethodInfo spelled out, sessionId everywhere, legacy registration obsolete

"method" is the JSON-RPC callable named on the wire and a MethodInfo is
always spelled MethodInfo: RpcMethod.FromMethod is FromMethodInfo and
RpcInterfaceMethod.Method is MethodInfo. The session parameter is
spelled sessionId on every overload; BindService, Handler.RegisterInstance
and the JsonRpcService(string) constructor used sessionID. Handler gets a
class summary and SessionSelector's summary says the selection is
independent of ASP.NET Core session state.

Handler.RegisterFuction and UnRegisterFunction keep their names and
behaviour and are obsolete; the message says that BindMethod throws on a
duplicate name where RegisterFuction replaces it. Tests that exercise the
legacy pair suppress CS0618 locally.

The README defines "method" at the top of Defining methods and "session"
at the top of Sessions and context; the package README gets the method
sentence; CHANGELOG and the upgrade guide record the renames.

Author: Astn

AustinHarris.JsonRpc.AspNetCore/JsonRpcOptions.cs

@@ -16,8 +16,9 @@ public class JsonRpcOptions
         public string SessionId { get; set; }
 
         /// <summary>
-        /// Picks the session per HTTP request (for example from a route value or a header). When set it takes
-        /// precedence over <see cref="SessionId"/>. Not used by the raw connection handler.
+        /// Selects the JSON-RPC session id for this HTTP request, for example from a route value or a header;
+        /// selection is independent of ASP.NET Core session state unless the callback explicitly uses it.
+        /// When set it takes precedence over <see cref="SessionId"/>. Not used by the raw connection handler.
         /// </summary>
         public Func<HttpContext, string> SessionSelector { get; set; }
 

AustinHarris.JsonRpcTestN/AsyncInvocationTests.cs

@@ -140,7 +140,9 @@ public async Task CompatibilityRegistrationSurfaces_SupportAsyncMethods(int surf
             var method = new Func<Task<int>>(() => Task.FromResult(7));
             var handler = Handler.GetSessionHandler(_session);
             if (surface == 0) handler.MetaData.Services["run"] = new SMDService("POST", "JSON-RPC-2.0", types, new Dictionary<string, object>(), method);
+#pragma warning disable CS0618
             else if (surface == 1) handler.RegisterFuction("run", types, null, method);
+#pragma warning restore CS0618
             else _ = new AutoAsyncService(_session);
             Assert.AreEqual(7, (int)JObject.Parse(await Run(Request("run")))["result"]);
             Assert.AreEqual(typeof(int), handler.MetaData.Services["run"].Method.ResultType);
@@ -172,13 +174,15 @@ public void AsyncVoid_IsRejectedOnEverySurface(int surface)
             var types = new Dictionary<string, Type> { ["returns"] = typeof(void) };
             TestDelegate registration = surface switch
             {
-                0 => () => RpcMethod.FromMethod("invalid", typeof(InvalidService).GetMethod("Invalid"), new InvalidService()),
+                0 => () => RpcMethod.FromMethodInfo("invalid", typeof(InvalidService).GetMethod("Invalid"), new InvalidService()),
                 1 => () => RpcMethod.FromDelegate("invalid", invalid),
                 2 => () => ServiceBinder.BindService(_session, new InvalidService()),
                 3 => () => Bind("invalid", invalid),
                 4 => () => new InvalidAutoService(_session),
                 5 => () => new SMDService("POST", "JSON-RPC-2.0", types, new Dictionary<string, object>(), invalid),
+#pragma warning disable CS0618
                 _ => () => Handler.GetSessionHandler(_session).RegisterFuction("invalid", types, null, invalid)
+#pragma warning restore CS0618
             };
             StringAssert.Contains("async void", Assert.Throws<NotSupportedException>(registration).Message);
         }

AustinHarris.JsonRpcTestN/DelegateBindingTests.cs

@@ -128,7 +128,9 @@ public void Names_MustBeFree_AndUnbindFreesThem()
             Assert.AreEqual("{\"jsonrpc\":\"2.0\",\"result\":2,\"id\":1}", Run("{\"method\":\"m\",\"id\":1}"));
 
             // the legacy surface keeps replacing silently
+#pragma warning disable CS0618
             Handler.GetSessionHandler(Session).RegisterFuction("m", new Dictionary<string, Type> { ["returns"] = typeof(int) }, null, new Func<int>(() => 3));
+#pragma warning restore CS0618
             Assert.AreEqual("{\"jsonrpc\":\"2.0\",\"result\":3,\"id\":1}", Run("{\"method\":\"m\",\"id\":1}"));
         }
 

AustinHarris.JsonRpcTestN/DiLifetimeTests.cs

@@ -640,7 +640,7 @@ public void Arguments_AreChecked()
             Assert.Throws<ArgumentNullException>(() => ServiceBinder.BindService(_session, (object)null));
             Assert.Throws<ArgumentException>(() => ServiceBinder.BindService(_session, typeof(List<>), c => null));
             var method = typeof(TaggedService).GetMethod(nameof(TaggedService.Tag));
-            var ex = Assert.Throws<ArgumentException>(() => AustinHarris.JsonRpc.Invocation.RpcMethod.FromMethod("fb.tag", method, typeof(string), c => null));
+            var ex = Assert.Throws<ArgumentException>(() => AustinHarris.JsonRpc.Invocation.RpcMethod.FromMethodInfo("fb.tag", method, typeof(string), c => null));
             StringAssert.Contains(typeof(TaggedService).FullName, ex.Message);
         }
     }

AustinHarris.JsonRpcTestN/DispatchHardeningTests.cs

@@ -154,7 +154,9 @@ public void BindServices()
         public void DestroySessions()
         {
             Handler.DestroySession(Session);
+#pragma warning disable CS0618
             Handler.DefaultHandler.UnRegisterFunction("dh.whichSession");
+#pragma warning restore CS0618
         }
 
         private static string Run(string json, object context = null, JsonRpcSerializer serializer = null, string session = Session)

AustinHarris.JsonRpcTestN/InterfaceBindingTests.cs

@@ -261,7 +261,7 @@ public void Include_ReadsHostAttributeForEveryAlias()
             var seen = new List<RpcInterfaceMethod>();
             using var binding = ServiceBinder.BindInterface<IAliases>(Session, new Aliases(), new RpcInterfaceBindingOptions
             {
-                Include = method => { seen.Add(method); return method.Method.IsDefined(typeof(ExportAttribute), false); }
+                Include = method => { seen.Add(method); return method.MethodInfo.IsDefined(typeof(ExportAttribute), false); }
             });
             Assert.AreEqual(3, seen.Count);
             CollectionAssert.AreEquivalent(new[] { "ALIAS", "OtherAlias" }, binding.Methods);

AustinHarris.JsonRpcTestN/NewtonsoftTests.cs

@@ -93,7 +93,9 @@ public void Settings_PerSession_OverridesGlobal()
             try
             {
                 var h = Handler.GetSessionHandler(sessionId);
+#pragma warning disable CS0618
                 h.RegisterFuction("echo", new System.Collections.Generic.Dictionary<string, Type> { { "s", typeof(string) }, { "returns", typeof(string) } }, null, new Func<string, string>(s => s));
+#pragma warning restore CS0618
                 h.Serializer = new NewtonsoftJsonRpcSerializer(new JsonSerializerSettings { Converters = { new ShoutingStringConverter() } });
                 // four arguments on purpose: ProcessSync(sessionId, json, null) binds to the (jsonRpc, context, serializer) overload
                 var result = JsonRpcProcessor.ProcessSync(sessionId, "{\"method\":\"echo\",\"params\":[\"abc\"],\"id\":1}", null, null);

AustinHarris.JsonRpcTestN/SessionAndConfigTests.cs

@@ -250,8 +250,10 @@ public void JsonRpcService_AutoBindFalse_BindsNowhere_UntilBoundExplicitly()
             }
             finally
             {
+#pragma warning disable CS0618
                 Handler.DefaultHandler.UnRegisterFunction("sc.bound");
                 Handler.GetSessionHandler(Session).UnRegisterFunction("sc.unbound");
+#pragma warning restore CS0618
             }
         }
     }

AustinHarris.JsonRpcTestN/Test.cs

@@ -95,7 +95,9 @@ public void TestCanCreateAndRemoveSession()
                 Tuple.Create ("sooper", typeof(string)),
                 Tuple.Create ("returns", typeof(string))
             }.ToDictionary(x => x.Item1, x => x.Item2);
+#pragma warning disable CS0618
             h.RegisterFuction("workie", metadata, new System.Collections.Generic.Dictionary<string, object>(),new Func<string, string>(x => "workie ... " + x));
+#pragma warning restore CS0618
 
             string request = @"{""method"":""workie"",""params"":{""sooper"":""good""},""id"":1}";
             string expectedResult = "{\"jsonrpc\":\"2.0\",\"result\":\"workie ... good\",\"id\":1}";
@@ -1612,7 +1614,9 @@ public void TestPreProcessOnSession()
                 Tuple.Create ("sooper", typeof(string)),
                 Tuple.Create ("returns", typeof(string))
             }.ToDictionary(x => x.Item1, x => x.Item2);
+#pragma warning disable CS0618
             h.RegisterFuction("workie", metadata, new System.Collections.Generic.Dictionary<string, object>(),new Func<string, string>(x => "workie ... " + x));
+#pragma warning restore CS0618
 
             string request = @"{""method"":""workie"",""params"":{""sooper"":""good""},""id"":1}";
             string expectedResult = "{\"jsonrpc\":\"2.0\",\"result\":\"workie ... good\",\"id\":1}";
@@ -1852,7 +1856,9 @@ public void TestPostProcessOnSession()
                 Tuple.Create ("sooper", typeof(string)),
                 Tuple.Create ("returns", typeof(string))
             }.ToDictionary(x => x.Item1, x => x.Item2);
+#pragma warning disable CS0618
             h.RegisterFuction("workie", metadata, new System.Collections.Generic.Dictionary<string, object>(), new Func<string, string>(x => "workie ... " + x));
+#pragma warning restore CS0618
 
             string request = @"{""method"":""workie"",""params"":{""sooper"":""good""},""id"":1}";
             string expectedResult = "{\"jsonrpc\":\"2.0\",\"result\":\"workie ... good\",\"id\":1}";

CHANGELOG.md

@@ -29,6 +29,9 @@ behaviour: a breaking change to either means a new major version.
 
 ### Changed
 
+- `RpcMethod.FromMethod` is `RpcMethod.FromMethodInfo`; `RpcInterfaceMethod.Method` is `RpcInterfaceMethod.MethodInfo`. A `MethodInfo` is always spelled out; "method" means the JSON-RPC method.
+- The session parameter is spelled `sessionId` on every overload (`BindService`, `Handler.RegisterInstance` and the `JsonRpcService` constructor used `sessionID`).
+- `Handler.RegisterFuction` and `UnRegisterFunction` are obsolete; use `ServiceBinder.BindMethod` and `UnbindMethod` (which throw on a duplicate name instead of replacing it).
 - The core no longer depends on Json.NET.
 - `ProcessAsync` no longer serializes the process on one lock per document. Each thread now caches one async scratch (input copy, reader, staged output) in front of the shared pool, which handles only misses and overflow. At 16 workers, the inline rows went from about 4 M to 22.2 M to 32.1 M RPC/s across the registrations, and the row with a real suspension from 3.9 M to 8.96 M (one run per row, 2026-09-25). The library retains one scratch per thread that has run `ProcessAsync` plus 64 shared, with buffers at most 64 KiB each.
 - The request path looks sessions up without creating them. A request for a session id that was never registered answers `-32601` for every call and leaves the registry untouched; sessions are created by binding and by the per-session `Config` setters. Registration adds the session before publishing the registry version, so a thread that misses its snapshot consults the master registry and cannot answer `-32601` for a session that exists.