ResolutionResult ResolveNamedInstanceDictionary(ResolutionRequest request)
{
var keyType = dictionaryFactory.GetKeyType(request.ServiceType);
var valueType = dictionaryFactory.GetValueType(request.ServiceType);
var dictionary = dictionaryFactory.Create(keyType, valueType);
var allServiceTypeRegistrations = registrationAccessor.GetAll(valueType);
foreach (var registration in allServiceTypeRegistrations)
{
var serviceResult = ResolveSingleInstance(registration, request);
if (!serviceResult.IsSuccess)
{
// TODO: Throw an exception? Return a failed resolution result? Currently I'm silently skipping the registration.
continue;
}
var dictionaryKey = ConvertToNameType(registration.Name, keyType);
dictionary.Add(dictionaryKey, serviceResult.ResolvedObject);
}
var dictionaryRegistration = CreateNamedInstanceDictionaryRegistration(request.ServiceType, dictionary);
var resolutionPath = request.ResolutionPath.CreateChild(dictionaryRegistration);
return(ResolutionResult.Success(resolutionPath, dictionary));
}
public void Resolve_using_request_can_get_registered_service_without_name(IServiceRegistrationProvider provider,
[Registration] IServiceRegistration registration,
ResolutionRequest request)
{
// Arrange
var sut = GetSut(provider);
var instance = new SampleServiceImplementationOne();
Mock.Get(provider)
.Setup(x => x.CanFulfilRequest(request))
.Returns(false);
Mock.Get(provider)
.Setup(x => x.Get(request))
.Returns((IServiceRegistration)null);
Mock.Get(provider)
.Setup(x => x.CanFulfilRequest(It.Is <ResolutionRequest>(r => r.ServiceType == request.ServiceType && r.Name == null)))
.Returns(true);
Mock.Get(provider)
.Setup(x => x.Get(It.Is <ResolutionRequest>(r => r.ServiceType == request.ServiceType && r.Name == null)))
.Returns(registration);
Mock.Get(registration)
.Setup(x => x.GetFactoryAdapter(request))
.Returns(new InstanceFactory(instance));
// Act
var result = sut.Resolve(request);
// Assert
Assert.That(result.ResolvedObject, Is.SameAs(instance));
}
private async Task SendResolutionRequestAsync(ResolutionRequest request)
{
var instrument = request.Instrument;
var data = await InstrumentConverter.ResolveInstrumentAsync(adapter, instrument);
// если символ не зарезолвился, выходим
if (data == null)
{
request.Resolve(uint.MaxValue);
return;
}
var message = new InformationRequest
{
symbol_resolution_request = new SymbolResolutionRequest {
symbol = data.Symbol
},
id = request.Id
};
request.OnSent();
using (requestBatchLock.Lock())
{
requestBatch.Add(message);
}
_Log.Debug().PrintFormat(
"Sending a symbol resolution request {0} for instrument {1} mapped to symbol {2}",
request.Id,
instrument,
data.Symbol
);
}
/// <summary>
/// Gets a value indicating whether or not the container has a registration for the specified component type.
/// </summary>
/// <returns>
/// <c>true</c>, if the container has a registration for the component type, <c>false</c> otherwise.</returns>
/// <param name="name">An optional registration name.</param>
/// <param name="serviceType">The component type for which to check.</param>
public bool HasRegistration(Type serviceType, string name = null)
{
AssertNotDisposed();
var request = new ResolutionRequest(serviceType, name);
return(registryStack.CanFulfilRequest(request));
}
/// <summary>
/// Attempts to resolve a component, as specified by a <see cref="T:CSF.FlexDi.Resolution.ResolutionRequest" /> instance.
/// The result indicates whether resolution was successful or not, and if it is, contains a reference to the resolved
/// component.
/// </summary>
/// <returns>A resolution result instance.</returns>
/// <param name="request">A resolution request specifying what is to be resolved.</param>
public ResolutionResult TryResolve(ResolutionRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
return(resolver.Resolve(request));
}
/// <summary>
/// Gets a value which indicates whether or not the current provider can fulfil the given resolution request.
/// </summary>
/// <returns>
/// <c>true</c>, if the request can be fulfilled, <c>false</c> otherwise.</returns>
/// <param name="request">A resolution request.</param>
public virtual bool CanFulfilRequest(ResolutionRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
return(true);
}
/// <summary>
/// Gets a value which indicates whether or not the current provider can fulfil the given resolution request.
/// </summary>
/// <returns>
/// <c>true</c>, if the request can be fulfilled, <c>false</c> otherwise.</returns>
/// <param name="request">A resolution request.</param>
public bool CanFulfilRequest(ResolutionRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
return(providers.Any(x => x.CanFulfilRequest(request)));
}
/// <summary>
/// Creates a service registration key based on a given resolution request.
/// </summary>
/// <returns>The registration key.</returns>
/// <param name="request">Request.</param>
public static ServiceRegistrationKey FromRequest(ResolutionRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
return(new ServiceRegistrationKey(request.ServiceType, request.Name));
}
IServiceRegistration IServiceRegistrationProvider.Get(ResolutionRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var key = ServiceRegistrationKey.FromRequest(request);
return(Get(key));
}
/// <summary>
/// Gets the registration which corresponds to a given resolution request.
/// </summary>
/// <returns>The registration.</returns>
/// <param name="request">Request.</param>
public override IServiceRegistration GetRegistration(ResolutionRequest request)
{
var registration = base.GetRegistration(request);
if (registration != null)
{
return(registration);
}
return(GetUnregisteredServiceRegistration(request));
}
/// <summary>
/// Resolves the given resolution request and returns the result.
/// </summary>
/// <param name="request">Request.</param>
public override ResolutionResult Resolve(ResolutionRequest request)
{
var output = ProxiedResolver.Resolve(request);
if (output.IsSuccess)
{
return(output);
}
return(fallbackResolver.Resolve(request));
}
/// <summary>
/// Resolves the given resolution request and returns the result.
/// </summary>
/// <param name="request">Request.</param>
public override ResolutionResult Resolve(ResolutionRequest request)
{
var registration = GetRegistration(request);
if (registration != null)
{
circularDependencyDetector.ThrowOnCircularDependency(registration, request.ResolutionPath);
}
return(ProxiedResolver.Resolve(request));
}
bool IsRequestForNamedInstanceDictionary(ResolutionRequest request)
{
if (!dictionaryFactory.IsGenericDictionaryType(request.ServiceType))
{
return(false);
}
var keyType = dictionaryFactory.GetKeyType(request.ServiceType);
return(keyType == typeof(string) || keyType.GetTypeInfo().IsEnum);
}
/// <summary>
/// Resolves a component, as specified by a <see cref="T:CSF.FlexDi.Resolution.ResolutionRequest" /> instance.
/// </summary>
/// <param name="request">The resolved component instance.</param>
public object Resolve(ResolutionRequest request)
{
var result = TryResolve(request);
if (!result.IsSuccess)
{
ThrowResolutionFailureException(request.ServiceType);
}
return(result.ResolvedObject);
}
bool IServiceRegistrationProvider.CanFulfilRequest(ResolutionRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var key = ServiceRegistrationKey.FromRequest(request);
return(Contains(key));
}
public void GetCopyWithoutName_does_not_copy_the_name(Type type, string name, ResolutionPath path)
{
// Arrange
var sut = new ResolutionRequest(type, name, path);
// Act
var result = sut.GetCopyWithoutName();
// Assert
Assert.That(result.Name, Is.Null);
}
public void GetCopyWithoutName_copies_resolution_path(Type type, string name, ResolutionPath path)
{
// Arrange
var sut = new ResolutionRequest(type, name, path);
// Act
var result = sut.GetCopyWithoutName();
// Assert
Assert.That(result.ResolutionPath, Is.SameAs(path));
}
public void Resolve_can_create_dictionary_of_instances_by_enum_values([Frozen, ResolvesToFailure] IResolver proxiedResolver,
[Frozen] IDictionaryFactory dictionaryFactory,
[Frozen] IServiceRegistrationProvider registrationProvider,
NamedInstanceDictionaryResolverProxy sut,
ResolutionRequest request,
SampleEnum[] names,
ResolutionPath path)
{
// Arrange
var serviceType = request.ServiceType;
var keyType = typeof(SampleEnum);
var valueType = typeof(ISampleService);
Mock.Get(dictionaryFactory)
.Setup(x => x.IsGenericDictionaryType(serviceType))
.Returns(true);
Mock.Get(dictionaryFactory)
.Setup(x => x.GetKeyType(serviceType))
.Returns(keyType);
Mock.Get(dictionaryFactory)
.Setup(x => x.GetValueType(serviceType))
.Returns(valueType);
Mock.Get(dictionaryFactory)
.Setup(x => x.Create(keyType, valueType))
.Returns(() => new Dictionary <SampleEnum, ISampleService>());
var registrations = names
.Select(x => x.ToString())
.Select(x => Mock.Of <IServiceRegistration>(r => r.Name == x && r.ServiceType == valueType))
.ToArray();
Mock.Get(registrationProvider)
.Setup(x => x.GetAll(valueType))
.Returns(registrations);
Mock.Get(proxiedResolver)
.Setup(x => x.Resolve(It.Is <ResolutionRequest>(r => r.ServiceType == valueType)))
.Returns((ResolutionRequest r) => ResolutionResult.Success(path, new SampleServiceImplementationOne()));
// Act
var result = sut.Resolve(request);
// Assert
Mock.Get(proxiedResolver)
.Verify(x => x.Resolve(It.Is <ResolutionRequest>(r => r.ServiceType == valueType)), Times.Exactly(names.Length));
foreach (var name in names.Select(x => x.ToString()).ToArray())
{
Mock.Get(proxiedResolver)
.Verify(x => x.Resolve(It.Is <ResolutionRequest>(r => r.Name == name)), Times.Once);
}
Assert.That(result.IsSuccess, Is.True);
Assert.That(result.ResolvedObject, Is.InstanceOf <IDictionary <SampleEnum, ISampleService> >());
var resolvedObject = (IDictionary <SampleEnum, ISampleService>)result.ResolvedObject;
Assert.That(resolvedObject, Has.Count.EqualTo(names.Length));
}
public void Resolve_uses_proxied_resolver_when_request_is_not_for_a_string([Frozen, ResolvesToFailure] IResolver proxiedResolver,
RegisteredNameInjectingResolverProxy sut)
{
// Arrange
var request = new ResolutionRequest(typeof(ISampleService));
// Act
var result = sut.Resolve(request);
// Assert
Mock.Get(proxiedResolver)
.Verify(x => x.Resolve(request), Times.Once);
}
public void Resolve_resolves_from_proxied_resolver_when_resolution_path_is_empty([ResolvesToFailure] IResolver proxiedResolver)
{
// Arrange
var sut = new DynamicRecursionResolverProxy(proxiedResolver);
var request = new ResolutionRequest(typeof(IResolvesServices), new ResolutionPath());
// Act
sut.Resolve(request);
// Assert
Mock.Get(proxiedResolver).Verify(x => x.Resolve(request), Times.Once);
Mock.Get(proxiedResolver).Verify(x => x.Resolve(It.Is <ResolutionRequest>(r => r != request)), Times.Never);
}
public void Resolve_returns_failure_result_if_container_cannot_be_resolved([ResolvesToFailure] IResolver proxiedResolver,
[Registration] IServiceRegistration registration)
{
// Arrange
var sut = new DynamicRecursionResolverProxy(proxiedResolver);
var request = new ResolutionRequest(typeof(IResolvesServices), new ResolutionPath(registration));
// Act
var result = sut.Resolve(request);
// Assert
Assert.That(result.IsSuccess, Is.False);
}
/// <summary>
/// Resolves the given resolution request and returns the result.
/// </summary>
/// <param name="request">Request.</param>
public override ResolutionResult Resolve(ResolutionRequest request)
{
var result = ProxiedResolver.Resolve(request);
if (result.IsSuccess)
{
return(result);
}
var defaultValue = GetDefaultForType(request.ServiceType);
return(ResolutionResult.Success(request.ResolutionPath, defaultValue));
}
/// <summary>
/// Resolves the given resolution request and returns the result.
/// </summary>
/// <param name="request">Request.</param>
public override ResolutionResult Resolve(ResolutionRequest request)
{
if (!lazyFactory.IsLazyType(request.ServiceType))
{
return(ProxiedResolver.Resolve(request));
}
var lazyInnerType = lazyFactory.GetInnerLazyType(request.ServiceType);
var lazyRequest = GetLazyResolutionRequest(request, lazyInnerType);
var lazyObject = lazyFactory.GetLazyObject(lazyInnerType, GetObjectFactory(lazyRequest));
return(ResolutionResult.Success(request.ResolutionPath, lazyObject));
}
/// <summary>
/// Gets a registration.
/// </summary>
/// <param name="request">A resolution request.</param>
public virtual IServiceRegistration Get(ResolutionRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
return(new TypeRegistration(request.ServiceType, constructorSelector)
{
Name = request.Name,
ServiceType = request.ServiceType,
Cacheable = true
});
}
public void Resolve_resolves_from_proxied_resolver_when_service_type_is_not_IResolvesServices([ResolvesToFailure] IResolver proxiedResolver,
[Registration] IServiceRegistration registration)
{
// Arrange
var sut = new DynamicRecursionResolverProxy(proxiedResolver);
var request = new ResolutionRequest(typeof(ISampleService), new ResolutionPath(registration));
// Act
sut.Resolve(request);
// Assert
Mock.Get(proxiedResolver).Verify(x => x.Resolve(request), Times.Once);
Mock.Get(proxiedResolver).Verify(x => x.Resolve(It.Is <ResolutionRequest>(r => r != request)), Times.Never);
}
/// <summary>
/// Resolves the given resolution request and returns the result.
/// </summary>
/// <param name="request">Request.</param>
public override ResolutionResult Resolve(ResolutionRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (!IsRequestForNamedInstanceDictionary(request))
{
return(ProxiedResolver.Resolve(request));
}
return(ResolveNamedInstanceDictionary(request));
}
public void Get_returns_null_when_no_provider_can_fulfil_the_request(IServiceRegistrationProvider[] providers,
ResolutionRequest request)
{
// Arrange
Mock.Get(providers[0]).Setup(x => x.CanFulfilRequest(request)).Returns(false);
Mock.Get(providers[1]).Setup(x => x.CanFulfilRequest(request)).Returns(false);
Mock.Get(providers[2]).Setup(x => x.CanFulfilRequest(request)).Returns(false);
var sut = new StackOfRegistriesRegistrationProvider(providers);
// Act
var result = sut.Get(request);
// Assert
Assert.That(result, Is.Null);
}
/// <summary>
/// Resolves the given resolution request and returns the result.
/// </summary>
/// <param name="request">Request.</param>
public override ResolutionResult Resolve(ResolutionRequest request)
{
var output = ProxiedResolver.Resolve(request);
if (output.IsSuccess)
{
return(output);
}
var registration = GetUnregisteredServiceRegistration(request);
output = registrationResolver.Resolve(request, registration);
MakeRegistrationAndResultAvailableToSubsequentResolutions(registration, output);
return(output);
}
/// <summary>
/// Attempts to resolve an instance of the specified type and using the given named registration, but
/// does not raise an exception if resolution fails.
/// </summary>
/// <returns>
/// <c>true</c>, if resolution was successful, <c>false</c> otherwise.</returns>
/// <param name="output">The resolved component instance.</param>
/// <param name="name">The registration name.</param>
/// <param name="serviceType">The component type to be resolved.</param>
public bool TryResolve(Type serviceType, string name, out object output)
{
AssertNotDisposed();
var request = new ResolutionRequest(serviceType, name);
var result = TryResolve(request);
if (!result.IsSuccess)
{
output = null;
return(false);
}
output = result.ResolvedObject;
return(true);
}
/// <summary>
/// Gets a registration.
/// </summary>
/// <param name="request">A resolution request.</param>
public IServiceRegistration Get(ResolutionRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var provider = providers.FirstOrDefault(x => x.CanFulfilRequest(request));
if (provider == null)
{
return(null);
}
return(provider.Get(request));
}
