private void OnServiceDiscovered(object sender, ResonanceDiscoveredServiceEventArgs <ResonanceSignalRDiscoveredService <DemoServiceInformation>, DemoServiceInformation> e)
{
InvokeUI(() =>
{
RegisteredServices.Add(e.DiscoveredService.DiscoveryInfo);
});
}
public static void Register <T>(string serviceName, T obj)
{
if (!RegisteredServices.TryAdd(serviceName, obj))
{
throw new Exception($"Service {serviceName} has already been registered.");
}
}
private async void ResetDiscovery()
{
await _discoveryClient.StopAsync();
RegisteredServices.Clear();
_discoveryClient.HubUrl = HubUrl;
_discoveryClient.Credentials = new DemoCredentials()
{
Name = ClientID
};
try
{
IsFree = false;
await _discoveryClient.StartAsync();
}
catch (Exception ex)
{
Logger.LogError(ex, "Error starting discovery service. Make sure the remote SignalR Hub is running.");
}
finally
{
IsFree = true;
}
}
public static void Register <T>(string serviceName, T obj)
{
if (RegisteredServices.ContainsKey(serviceName))
{
throw new Exception($"Service {serviceName} has already been registered.");
}
RegisteredServices.Add(serviceName, obj);
}
/// <summary>
/// Handle incoming data from the websocket.
/// </summary>
/// <remarks>Check it is valid, handle if RPC.</remarks>
/// <param name="client">The client connection.</param>
/// <param name="jsonMessage">The message payload as JSON.</param>
private void HandleMessage(IWebSocketConnection client, String jsonMessage)
{
// Convert to BlipRequest.
BlipRequest request = null;
try
{
request = JsonConvert.DeserializeObject <BlipRequest>(jsonMessage);
request.Validate();
}
catch (Exception e)
{
if (LogWarning != null)
{
LogWarning(this, "Dropped bad Blip request from " + client.ConnectionInfo.ClientIpAddress);
}
return;
}
// Locate target delegate.
Delegate target;
if (!RegisteredServices.TryGetValue(request.Target, out target))
{
if (LogWarning != null)
{
LogWarning(this, "Missing RPC registered handler for target from " + client.ConnectionInfo.ClientIpAddress);
}
return;
}
// Dynamic invoke.
String responseJson = null;
try
{
var result = target.DynamicInvoke(request.Arguments);
responseJson = JsonConvert.SerializeObject(new BlipResponse()
{
Target = request.Call, Success = true, Result = result
});
}
catch (Exception e)
{
var err = e.InnerException;
if (err != null)
{
e = err;
}
responseJson = JsonConvert.SerializeObject(new BlipResponse()
{
Target = request.Call, Success = false, Result = new { Message = e.Message, Stacktrace = e.StackTrace }
});
}
// Pass it back.
DispatchData(client, responseJson);
}
/// <summary>
/// 使用契约接口注册Http请求服务
/// </summary>
/// <typeparam name="TService">契约接口类型</typeparam>
/// <param name="baseUrl">服务器地址，不填时需要在契约接口标记HttpHost特性</param>
public void AddService <TService>(string baseUrl = null)
{
if (!typeof(TService).IsInterface)
{
throw new ArgumentOutOfRangeException($"{typeof(TService).Name} is not a interface.");
}
RegisteredServices.Add(new KeyValuePair <string, Type>(baseUrl, typeof(TService)));
}
public static void Register(Type type, object obj)
{
var serviceName = GetServiceRegistrationName(type);
if (!RegisteredServices.TryAdd(serviceName, obj))
{
throw new Exception($"Service {serviceName} has already been registered.");
}
}
public static object Resolve(Type type)
{
var serviceName = GetServiceRegistrationName(type);
if (RegisteredServices.TryGetValue(serviceName, out var service))
{
return(service);
}
throw new Exception($"Service {serviceName} is not registered.");
}
public static T Resolve <T>(string serviceName, bool dontThrow = false)
{
if (RegisteredServices.ContainsKey(serviceName))
{
return((T)RegisteredServices[serviceName]);
}
if (dontThrow)
{
return((T)(object)null);
}
throw new Exception($"Service {serviceName} is not registered.");
}
public static T Resolve <T>(string serviceName, bool dontThrow = false)
{
if (RegisteredServices.TryGetValue(serviceName, out var service))
{
return((T)service);
}
if (dontThrow)
{
return((T)(object)null);
}
throw new Exception($"Service {serviceName} is not registered.");
}
public static void Reset()
{
foreach (var service in RegisteredServices)
{
if (service.Value != null && service.Value is IDisposable disposableService)
{
disposableService.Dispose();
}
}
Inited = false;
RegisteredServices.Clear();
RegisteredServices = new Dictionary <string, object>();
}
public void IfServiceDescriptorWithImplementationInstanceIsProvided_ThenNullIsReturned()
{
// Arrange
var registeredServices = new RegisteredServices <string, IFoo>();
var singletonDescriptor = ServiceDescriptor.Singleton <IFoo>(new Foo());
var key = "key";
// Act
Func <ServiceDescriptor> act = () => registeredServices.TryAddService(key, singletonDescriptor);
// Asset
var result = act.Should().NotThrow().Subject;
result.Should().BeNull();
}
private void ClearConnection()
{
IsConnected = false;
InvokeUI(async() =>
{
RegisteredServices.Clear();
_discoveryClient.Credentials = new DemoCredentials()
{
Name = ClientID
};
_discoveryClient.HubUrl = HubUrl;
await _discoveryClient.StartAsync();
});
}
public object ResolveService(Type type)
{
if (instances.TryGetValue(type, out object value))
{
return(value);
}
if (RegisteredServices.TryGetValue(type, out Type implementation))
{
ConstructorInfo[] infoCollection = GatherConstructors(implementation);
return(ConstructService(implementation, infoCollection));
}
throw new ArgumentException(
$"No services are registered that implement the given type: {type.ToString()}");
}
public void IfTheSameKeyIsAddedMultipleTimes_ThenOnlyFirstCallReturnsAdjustedServiceDescriptorAndSubsequentCallsRetunNull()
{
// Arrange
var registeredServices = new RegisteredServices <string, IFoo>();
var transientDescriptor = ServiceDescriptor.Transient <IFoo, Foo>();
var key = "key";
// Act
Func <(ServiceDescriptor, ServiceDescriptor, ServiceDescriptor)> act = () =>
(
registeredServices.TryAddService(key, transientDescriptor),
registeredServices.TryAddService(key, transientDescriptor),
registeredServices.TryAddService(key, transientDescriptor)
);
// Asset
using (new AssertionScope())
{
var(result1, result2, result3) = act.Should().NotThrow().Subject;
result1.Should().BeEquivalentTo(ServiceDescriptor.Transient <Foo, Foo>());
result2.Should().BeNull();
result3.Should().BeNull();
}
}
public static bool TryResolve(Type type, out object service)
{
var serviceName = GetServiceRegistrationName(type);
return(RegisteredServices.TryGetValue(serviceName, out service));
}
public static void Reset()
{
Inited = false;
RegisteredServices.Clear();
RegisteredServices = new Dictionary <string, object>();
}
