GetProxy simplification

Author: eduard-dumitru

src/Playground/Program.cs

@@ -87,7 +87,6 @@ private static async Task Main(string[] args)
             },
             Scheduler = clientScheduler
         }
-            .GetProxyFactory()
             .GetProxy<Contracts.IServerOperations>();
 
         await proxy1.Register();

src/UiPath.CoreIpc.BackCompat/Clients/NamedPipeClientBuilder.cs

@@ -1,5 +1,4 @@
-using UiPath.Ipc;
-using UiPath.Ipc.Transport.NamedPipe;
+using UiPath.Ipc.Transport.NamedPipe;
 
 namespace UiPath.Ipc.BackCompat;
 
@@ -68,6 +67,5 @@ protected override TInterface BuildCore(EndpointSettings? serviceEndpoint)
         BeforeCall = BeforeCall,
         Callbacks = serviceEndpoint.ToEndpointCollection()
     }
-        .GetProxyFactory()
         .GetProxy<TInterface>();
 }

src/UiPath.CoreIpc.BackCompat/Clients/TcpClientBuilder.cs

@@ -1,5 +1,4 @@
 using System.Net;
-using UiPath.Ipc;
 using UiPath.Ipc.Transport.Tcp;
 
 namespace UiPath.Ipc.BackCompat;
@@ -31,7 +30,6 @@ protected override TInterface BuildCore(EndpointSettings? serviceEndpoint)
             BeforeCall = BeforeCall,
             Callbacks = serviceEndpoint.ToEndpointCollection()
         }
-        .GetProxyFactory()
         .GetProxy<TInterface>();
 }
 

src/UiPath.CoreIpc.BackCompat/Clients/WebSocketClientBuilder.cs

@@ -1,5 +1,4 @@
-using UiPath.Ipc;
-using UiPath.Ipc.Transport.WebSocket;
+using UiPath.Ipc.Transport.WebSocket;
 
 namespace UiPath.Ipc.BackCompat;
 
@@ -25,7 +24,6 @@ protected override TInterface BuildCore(EndpointSettings? serviceEndpoint)
             BeforeCall = BeforeCall,
             Callbacks = serviceEndpoint.ToEndpointCollection(),
         }
-        .GetProxyFactory()
         .GetProxy<TInterface>();
 }
 

src/UiPath.CoreIpc/Client/ServiceClient.cs

@@ -1,5 +1,8 @@
 namespace UiPath.Ipc;
 
+using System.Linq.Expressions;
+using ServiceClientProperFactory = Func<ClientBase, Type, ServiceClient>;
+
 internal abstract class ServiceClient : IDisposable
 {
     #region " NonGeneric-Generic adapter cache "
@@ -26,6 +29,7 @@ private static InvokeDelegate CreateInvokeDelegate(Type returnType)
     public event EventHandler? ConnectionClosed;
 
     private readonly Type _interfaceType;
+    private readonly ContextfulLazy<IpcProxy> _proxy = new();
 
     protected ServiceClient(Type interfaceType)
     {
@@ -39,11 +43,19 @@ protected ServiceClient(Type interfaceType)
 
     protected abstract Task<(Connection connection, bool newlyConnected)> EnsureConnection(CancellationToken ct);
 
-    public T CreateProxy<T>() where T : class
+    public T GetProxy<T>() where T : class
     {
-        var proxy = DispatchProxy.Create<T, IpcProxy>();
-        (proxy as IpcProxy)!.ServiceClient = this;
-        return proxy;
+        if (!_interfaceType.IsAssignableTo(typeof(T)))
+        {
+            throw new ArgumentOutOfRangeException($"The provided generic argument T is not assignable to the proxy type. T is {typeof(T).Name}. The proxy type is {_interfaceType.Name}.");
+        }
+
+        return (_proxy.GetValue(() =>
+        {
+            var proxy = (DispatchProxy.Create<T, IpcProxy>() as IpcProxy)!;
+            proxy.ServiceClient = this;
+            return proxy;
+        }) as T)!;
     }
 
     private Task<TResult> Invoke<TResult>(MethodInfo method, object?[] args)
@@ -139,6 +151,40 @@ private void Dispose(bool disposing)
     public override string ToString() => DebugName;
 }
 
+internal static class ServiceClientProper
+{
+    private static readonly ConcurrentDictionary<Type, ServiceClientProperFactory> CachedFactories = new();
+    private static ServiceClientProperFactory GetFactory(Type clientType) => CachedFactories.GetOrAdd(clientType, CreateFactory);
+    private static ServiceClientProperFactory CreateFactory(Type clientType)
+    {
+        if (clientType
+            .GetInterfaces()
+            .SingleOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IClient<,>))
+            ?.GetGenericArguments()
+            is not [var clientStateType, var clientType2] || clientType2 != clientType)
+        {
+            throw new ArgumentOutOfRangeException(nameof(clientType), "The client implements 0 or more than 1 IClient<,> interfaces or the single interface's 2nd generic argument is not the client type itself.");
+        }
+
+        var ctor = typeof(ServiceClientProper<,>)
+            .MakeGenericType(clientStateType, clientType)
+            .GetConstructor([clientType, typeof(Type)])!;
+
+        var paramofClientBase = Expression.Parameter(typeof(ClientBase));
+        var paramofType = Expression.Parameter(typeof(Type));
+        return Expression.Lambda<ServiceClientProperFactory>(
+            Expression.New(
+                ctor, 
+                Expression.Convert(paramofClientBase, clientType), 
+                paramofType),
+            paramofClientBase,
+            paramofType).Compile();
+    }
+
+    public static ServiceClient Create(ClientBase client, Type proxyType)
+    => GetFactory(client.GetType())(client, proxyType);
+}
+
 internal sealed class ServiceClientProper<TClient, TClientState> : ServiceClient
     where TClient : ClientBase, IClient<TClientState, TClient>
     where TClientState : class, IClientState<TClient, TClientState>, new()

src/UiPath.CoreIpc/Extensibility/ClientBase.cs

@@ -1,9 +1,10 @@
-using UiPath.Ipc.Transport.Tcp;
-
-namespace UiPath.Ipc;
+namespace UiPath.Ipc;
 
 public abstract record ClientBase : EndpointConfig
 {
+    private readonly ConcurrentDictionary<Type, ServiceClient> _clients = new();
+    private ServiceClient GetServiceClient(Type proxyType) => _clients.GetOrAdd(proxyType, ServiceClientProper.Create(this, proxyType));
+
     public IServiceProvider? ServiceProvider { get; init; }
     public EndpointCollection? Callbacks { get; init; }
     public ILogger? Logger { get; init; }
@@ -16,9 +17,7 @@ public abstract record ClientBase : EndpointConfig
     public virtual void Validate() { }
 
     public TProxy GetProxy<TProxy>() where TProxy : class
-    => new ServiceClientProper<TClient, TClientState>(_client, typeof(TProxy))
-        .CreateProxy<TProxy>();
-
+    => GetServiceClient(typeof(TProxy)).GetProxy<TProxy>();
 
     internal void ValidateInternal()
     {
@@ -62,27 +61,6 @@ public interface IClient<TState, TSelf>
     where TSelf : ClientBase, IClient<TState, TSelf>
     where TState : class, IClientState<TSelf, TState>, new() { }
 
-public static class ClientExtensions
-{
-    public static ProxyFactory<TClient, TClientState> GetProxyFactory<TClient, TClientState>(this IClient<TClientState, TClient> client)
-        where TClient : ClientBase, IClient<TClientState, TClient>
-        where TClientState : class, IClientState<TClient, TClientState>, new()
-    => new(client as TClient ?? throw new ArgumentOutOfRangeException(nameof(client)));
-
-    public readonly struct ProxyFactory<TClient, TClientState>
-        where TClient : ClientBase, IClient<TClientState, TClient>
-        where TClientState : class, IClientState<TClient, TClientState>, new()
-    {
-        private readonly TClient _client;
-
-        internal ProxyFactory(TClient client) => _client = client;
-
-        public TProxy GetProxy<TProxy>() where TProxy : class
-        => new ServiceClientProper<TClient, TClientState>(_client, typeof(TProxy))
-            .CreateProxy<TProxy>();
-    }
-}
-
 public interface IClientState<TClient, TSelf> : IDisposable
     where TSelf : class, IClientState<TClient, TSelf>, new()
     where TClient : ClientBase, IClient<TSelf, TClient>

src/UiPath.CoreIpc/GlobalUsings.cs

@@ -5,4 +5,4 @@
 global using Accept = System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<System.Net.WebSockets.WebSocket>>;
 global using Network = UiPath.Ipc.Extensibility.OneOf<UiPath.Ipc.IAsyncStream, System.IO.Stream>;
 global using ContractToSettingsMap = System.Collections.Generic.Dictionary<string, UiPath.Ipc.EndpointSettings>;
-global using AccessControlDelegate = System.Action<System.IO.Pipes.PipeSecurity>;
+global using AccessControlDelegate = System.Action<System.IO.Pipes.PipeSecurity>;