HubConnectionExtensions.cs

Go to the documentation of this file.

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.SignalR.Client;
 
namespace Tgstation.Server.Client.Extensions
{
    static class HubConnectionExtensions
    {
        public static void ProxyOn<TClientProxy>(this HubConnection hubConnection, TClientProxy proxy)
            where TClientProxy : class
        {
            if (hubConnection == null)
                throw new ArgumentNullException(nameof(hubConnection));
 
            if (proxy == null)
                throw new ArgumentNullException(nameof(proxy));
 
            ProxyOn(hubConnection, typeof(TClientProxy), proxy);
        }
 
        static void ProxyOn(this HubConnection hubConnection, Type proxyType, object proxyObject)
        {
            var clientMethods = proxyType.GetMethods();
            var cancellationTokenType = typeof(CancellationToken);
            foreach (var clientMethod in clientMethods)
            {
                var parametersList = clientMethod
                    .GetParameters()
                    .Select(parameterInfo => parameterInfo.ParameterType)
                    .ToList();
 
                var cancellationTokenIndex = parametersList.IndexOf(cancellationTokenType);
                if (cancellationTokenIndex != -1)
                {
                    parametersList.RemoveAt(cancellationTokenIndex);
#if DEBUG
                    if (parametersList.IndexOf(cancellationTokenType) != -1)
                        throw new InvalidOperationException("Cannot ProxyOn a method with multiple CancellationToken parameters!");
#endif
                }
 
                var parameters = parametersList.ToArray();
 
                object?[] AddCancellationTokenToParametersArray(object?[] parametersArray)
                {
                    if (cancellationTokenIndex == -1)
                        return parametersArray;
 
                    var newList = parametersArray.ToList();
                    newList.Insert(cancellationTokenIndex, CancellationToken.None);
                    return newList.ToArray();
                }
 
                var returnType = clientMethod.ReturnType;
                if (returnType != typeof(Task))
                {
                    if (returnType.BaseType != typeof(Task))
                        throw new InvalidOperationException($"Return type {returnType} of {proxyType.FullName}.{clientMethod.Name} is not supported! Only Task and derivatives are supported.");
 
                    var resultProperty = returnType.GetProperty(nameof(Task<object>.Result));
                    hubConnection.On(
                        clientMethod.Name,
                        parameters,
                        async (parameterArray, _) =>
                        {
                            var task = (Task)clientMethod.Invoke(proxyObject, AddCancellationTokenToParametersArray(parameterArray));
                            await task;
                            return resultProperty.GetValue(task);
                        },
                        hubConnection);
                }
                else
                    hubConnection.On(
                        clientMethod.Name,
                        parameters,
                        (parameterArray) =>
                        {
                            return (Task)clientMethod.Invoke(proxyObject, AddCancellationTokenToParametersArray(parameterArray));
                        });
            }
 
            foreach (var inheritedInterface in proxyType.GetInterfaces())
                ProxyOn(hubConnection, inheritedInterface, proxyObject);
        }
    }
}