protected IWampRpcOperation CreateRpcMethod(object instance, ICalleeRegistrationInterceptor interceptor, MethodInfo method)
{
string procedureUri =
interceptor.GetProcedureUri(method);
if (!typeof(Task).IsAssignableFrom(method.ReturnType))
{
return(new SyncMethodInfoRpcOperation(instance, method, procedureUri));
}
else
{
#if !NET40
if (method.IsDefined(typeof(WampProgressiveResultProcedureAttribute)))
{
MethodInfoValidation.ValidateProgressiveMethod(method);
return(CreateProgressiveOperation(instance, method, procedureUri));
}
else
#endif
{
MethodInfoValidation.ValidateAsyncMethod(method);
return(new AsyncMethodInfoRpcOperation(instance, method, procedureUri));
}
}
}
protected IWampRpcOperation CreateRpcMethod(Func <object> instanceProvider, ICalleeRegistrationInterceptor interceptor, MethodInfo method)
{
string procedureUri =
interceptor.GetProcedureUri(method);
if (method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == typeof(IObservable <>))
{
MethodInfoValidation.ValidateProgressiveObservableMethod(method);
return(CreateProgressiveObservableOperation(instanceProvider, method, procedureUri));
}
else if (!typeof(Task).IsAssignableFrom(method.ReturnType))
{
MethodInfoValidation.ValidateSyncMethod(method);
return(new SyncMethodInfoRpcOperation(instanceProvider, method, procedureUri));
}
else
{
if (method.IsDefined(typeof(WampProgressiveResultProcedureAttribute)))
{
MethodInfoValidation.ValidateProgressiveMethod(method);
return(CreateProgressiveOperation(instanceProvider, method, procedureUri));
}
else
{
MethodInfoValidation.ValidateAsyncMethod(method);
return(new AsyncMethodInfoRpcOperation(instanceProvider, method, procedureUri));
}
}
}
private IEnumerable <OperationToRegister> GetServiceMethodsOfType
(Func <object> instance,
Type type,
ICalleeRegistrationInterceptor interceptor)
{
foreach (var method in type.GetPublicInstanceMethods())
{
if (interceptor.IsCalleeProcedure(method))
{
IWampRpcOperation operation = CreateRpcMethod(instance, interceptor, method);
RegisterOptions options = interceptor.GetRegisterOptions(method);
yield return(new OperationToRegister(operation, options));
}
}
}
public IEnumerable <OperationToRegister> ExtractOperations(object instance, ICalleeRegistrationInterceptor interceptor)
{
Type type = instance.GetType();
IEnumerable <Type> typesToExplore = GetTypesToExplore(type);
foreach (Type currentType in typesToExplore)
{
IEnumerable <OperationToRegister> currentOperations =
GetServiceMethodsOfType(instance, currentType, interceptor);
foreach (OperationToRegister operation in currentOperations)
{
yield return(operation);
}
}
}
public Task <IAsyncDisposable> RegisterCallee(object instance, ICalleeRegistrationInterceptor interceptor)
{
IEnumerable <OperationToRegister> operationsToRegister =
mExtractor.ExtractOperations(instance, interceptor);
List <Task <IAsyncDisposable> > registrations =
new List <Task <IAsyncDisposable> >();
foreach (OperationToRegister operationToRegister in operationsToRegister)
{
Task <IAsyncDisposable> task =
mProxy.RpcCatalog.Register(operationToRegister.Operation, operationToRegister.Options);
registrations.Add(task);
}
return(registrations.ToAsyncDisposableTask());
}
private static CompositeDisposable HostDisposableService(IWampHostedRealm hostedRealm, IDisposable service, ICalleeRegistrationInterceptor registrationInterceptor)
{
Task <IAsyncDisposable> registrationDisposable =
hostedRealm.Services.RegisterCallee(service, registrationInterceptor);
IAsyncDisposable asyncDisposable = registrationDisposable.Result;
IDisposable unregisterDisposable =
Disposable.Create(() => asyncDisposable.DisposeAsync().Wait());
CompositeDisposable result =
new CompositeDisposable(unregisterDisposable, service);
return(result);
}
public Task <IAsyncDisposable> RegisterCallee <TService>(Func <TService> instanceProvider,
ICalleeRegistrationInterceptor interceptor)
where TService : class
{
return(RegisterCallee(typeof(TService), instanceProvider, interceptor));
}
public Task <IAsyncDisposable> RegisterCallee(object instance, ICalleeRegistrationInterceptor interceptor)
{
return(RegisterCallee(instance.GetType(), () => instance, interceptor));
}
