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)); }