static IServiceProvider CreateContainer(IAzureFunctionsApi azureFunctionsApi, IGitHubApiV3 gitHubApiV3, IGitHubGraphQLApi gitHubGraphQLApi) { var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); //GitTrends Refit Services services.AddSingleton(azureFunctionsApi); services.AddSingleton(gitHubApiV3); services.AddSingleton(gitHubGraphQLApi); //GitTrends Services services.AddSingleton <AzureFunctionsApiService>(); services.AddSingleton <BackgroundFetchService>(); services.AddSingleton <DeepLinkingService>(); services.AddSingleton <NotificationService, ExtendedNotificationService>(); services.AddSingleton <GitHubApiV3Service>(); services.AddSingleton <GitHubApiRepositoriesService>(); services.AddSingleton <GitHubApiStatusService>(); services.AddSingleton <GitHubAuthenticationService>(); services.AddSingleton <GitHubGraphQLApiService>(); services.AddSingleton <GitHubUserService>(); services.AddSingleton <GitTrendsContributorsService>(); services.AddSingleton <FavIconService>(); services.AddSingleton <FirstRunService>(); services.AddSingleton <ImageCachingService>(); services.AddSingleton <LanguageService>(); services.AddSingleton <MediaElementService>(); services.AddSingleton <ReferringSitesDatabase>(); services.AddSingleton <RepositoryDatabase>(); services.AddSingleton <ReviewService>(); services.AddSingleton <MobileSortingService>(); services.AddSingleton <SyncfusionService>(); services.AddSingleton <ThemeService>(); services.AddSingleton <TrendsChartSettingsService>(); //GitTrends ViewModels services.AddTransient <OnboardingViewModel>(); services.AddTransient <ReferringSitesViewModel>(); services.AddTransient <RepositoryViewModel>(); services.AddTransient <SettingsViewModel>(); services.AddTransient <SplashScreenViewModel>(); services.AddTransient <TrendsViewModel>(); services.AddTransient <WelcomeViewModel>(); //Mocks services.AddSingleton <IAnalyticsService, MockAnalyticsService>(); services.AddSingleton <IAppInfo, MockAppInfo>(); services.AddSingleton <IBrowser, MockBrowser>(); services.AddSingleton <IDeviceNotificationsService, MockDeviceNotificationsService>(); services.AddSingleton <IFileSystem, MockFileSystem>(); services.AddSingleton <IEmail, MockEmail>(); services.AddSingleton <ILauncher, MockLauncher>(); services.AddSingleton <IMainThread, MockMainThread>(); services.AddSingleton <INotificationManager, MockNotificationManager>(); services.AddSingleton <ISecureStorage, MockSecureStorage>(); services.AddSingleton <IPreferences, MockPreferences>(); services.AddSingleton <IVersionTracking, MockVersionTracking>(); return(services.BuildServiceProvider()); }
public void AddPollyPolicy_ShouldRegisterCircuitBreakerManagerAsSingleton() { var serviceCollection = new ServiceCollectionImpl(); serviceCollection.AddPollyPolicy("Test", GetCircuitBreakerPolicy()); AssertManagerRegistered(serviceCollection); }
public ServiceCollection() { var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); services.AddServiceResolution(); _sut = services.BuildServiceProvider().GetRequiredService <ServiceFactory>(); }
public static void Configure(IConfiguration configuration) { IServiceCollection serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); serviceCollection.AddLogging(builder => builder.SetMinimumLevel(LogLevel.Trace)); serviceCollection.AddLogging(builder => builder.AddDynamicConsole()); LoggerFactory = serviceCollection.BuildServiceProvider().GetService <ILoggerFactory>(); }
private static void Main(string[] args) { Parser.Default.ParseArguments <Options>(args) .WithParsed <Options>(o => { if (o.Verbose) { Log.Logger = new LoggerConfiguration() .MinimumLevel.Verbose() .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}") .WriteTo.File("log.log", rollingInterval: RollingInterval.Day, outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}") .CreateLogger(); Log.Information("Application started."); Log.Verbose("Verbose output enabled."); } else { Log.Logger = new LoggerConfiguration() .MinimumLevel.Information() .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}") .WriteTo.File("log.log", rollingInterval: RollingInterval.Day, outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}") .CreateLogger(); Log.Information("Application started."); Log.Information("Error output enabled."); } Log.Information($"Application Start: {DateTime.Now}"); if (!Directory.Exists(o.Source)) { var m = $"Source directory \"{o.Source}\" does not exist!"; Log.Error(m); throw new Exception(m); } if (!Directory.Exists(o.Destination)) { var m = $"Destination directory \"{o.Destination}\" does not exist!"; Log.Error(m); throw new Exception(m); } //setup our DI var serviceProvider = new Microsoft.Extensions.DependencyInjection.ServiceCollection() .AddLogging() .AddSingleton <IWatermarkService, WatermarkService>() .BuildServiceProvider(); //do the actual work here var bar = serviceProvider.GetService <IWatermarkService>(); bar.DoThing(5); Log.Information($"Application Finished: {DateTime.Now}"); }); }
public void Configuration(IAppBuilder app) { var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); ConfigureAuth(app); ConfigureServices(services); var resolver = new DefaultDependencyResolver(services.BuildServiceProvider()); DependencyResolver.SetResolver(resolver); }
public static IAuthorizationService BuildAuthorizationService(Action <IServiceCollection> setupServices = null) { var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); services.AddAuthorization(); services.AddOptions(); services.AddLogging(); setupServices?.Invoke(services); return(services.BuildServiceProvider().GetRequiredService <IAuthorizationService>()); }
public void Medaitor_1AddLatransMedaitor() { var servicesWebApp = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); var b = servicesWebApp.AddLatransMedaitor(); //b.Build(); Assert.Contains(servicesWebApp, sd => typeof(IMediatorClientFactory) == sd.ServiceType); Assert.Contains(servicesWebApp, sd => typeof(IMediatorClient) == sd.ServiceType); Assert.Contains(servicesWebApp, sd => typeof(IMediatorService) == sd.ServiceType); }
public void AddPollyPolicies_ShouldRegisterCircuitBreakerManagerAsSingleton() { var serviceCollection = new ServiceCollectionImpl(); var dict = new Dictionary <string, ICircuitBreakerPolicy> { { "Test", GetCircuitBreakerPolicy() } }; serviceCollection.AddPollyPolicies(dict); AssertManagerRegistered(serviceCollection); }
public static async Task Main(string[] args) { var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); ConfigureServices(services); var provider = services.BuildServiceProvider(); var app = provider.GetService <Application>(); await app.Verify("password1"); }
public void ShouldLoadSomeServicesFromExecutingAssembly_CheckRegistrationByImplementation_LoadByAssembly() { var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); services.AddAutoRegister(Assembly.GetAssembly(typeof(ServiceCollectionProviderTests))); var provider = services.BuildServiceProvider(); var resolveService = provider.GetService <FirstClass>(); Assert.NotNull(resolveService); Assert.IsType <FirstClass>(resolveService); }
Clone(Microsoft.Extensions.DependencyInjection.IServiceCollection serviceCollection) { Microsoft.Extensions.DependencyInjection.IServiceCollection clone = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); foreach (Microsoft.Extensions.DependencyInjection.ServiceDescriptor service in serviceCollection) { clone.Add(service); } return(clone); }
public void ConcretionClassWithMultipleConstructorsIsRegisteredCorrectly() { // arrange var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); var sut = new ContainerSetup(serviceCollection); var act = new Action(() => sut.RetrieveConcretionClassesRequiringRegistration(true)); // act // assert act.Should().NotThrow <Exception>(); }
public void GetRequiredService_NotRegistered_ShouldThrow() { var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); var serviceProvider = serviceCollection.BuildServiceProvider(); Func <TestServiceTwoParams <string, double> > factory = () => serviceProvider.GetRequiredService <TestServiceTwoParams <string, double> >(); // This is actually checking already built-in behaviour, but illustrates the kind of exception thrown which we want to align with here factory.Should().Throw <InvalidOperationException>() .WithMessage($"No service for type '{typeof(TestServiceTwoParams<string, double>)}' has been registered."); }
public void Medaitor_2AddHandler() { var servicesWebApp = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); var servicesMediator = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); var b = servicesWebApp.AddLatransMedaitor(); b.AddActivityHandler <TestActivityHandler1>() .Build(); Assert.Contains(b.Services, sd => typeof(IActivityHandler <TestRequest1, TestResponse1>) == sd.ServiceType); }
public void ShouldLoadSomeServicesFromExecutingAssembly_CheckRegistrationByServiceType_LoadByType() { var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); services.AddAutoRegister(typeof(ServiceCollectionProviderTests)); var provider = services.BuildServiceProvider(); var resolveService = provider.GetService <ISecondClass>(); Assert.NotNull(resolveService); Assert.IsAssignableFrom <ISecondClass>(resolveService); }
public SampleExamContext CreateDbContext() { var config = new ConfigurationBuilder().AddEnvironmentVariables().Build(); var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); var connectionString = config.GetValue <string>(IntegrationTestConstants.CONN_STRING_KEY_TEST); services.AddDbContext <SampleExam.Infrastructure.Data.SampleExamContext>(opt => opt.UseNpgsql(connectionString)); var serviceProvider = services.BuildServiceProvider(); var dbContext = serviceProvider.GetRequiredService <SampleExamContext>(); return(dbContext); }
public async Task InvokeCall_succeeds() { var mockHttpContextAccessor = new Mock <IHttpContextAccessor>(); var mockHttpRequest = new Mock <HttpRequest>(); mockHttpRequest.Setup(_ => _.Headers) .Returns(new HeaderDictionary { { "tenantId", "1" } }); mockHttpContextAccessor.Setup(x => x.HttpContext.Request) .Returns(mockHttpRequest.Object); //setup serviceCollection var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); foreach (var tenant in _tenants) { if (tenant.Id == 1) { serviceCollection.AddTenantScoped(tenant, typeof(IFooService), typeof(DefaultFooService), ServiceLifetime.Scoped); } else { serviceCollection.AddTenantScoped(tenant, typeof(IFooService), typeof(SpecialFooService), ServiceLifetime.Scoped); } //this singleton is tenant scoped. //there will be a singleton for each tenant serviceCollection.AddTenantScoped(tenant, typeof(IBarService), typeof(BarService), ServiceLifetime.Singleton); } serviceCollection.AddSingleton(_ => mockHttpContextAccessor); serviceCollection.AddSingleton <ITenantProvider, MockTenantProvider>(); serviceCollection.AddSingleton <ITenantResolutionStrategy, HeaderTenantResolutionStrategy>(); serviceCollection.AddSingleton <IBazService, BazService>(); serviceCollection.AddSingleton(mockHttpContextAccessor.Object); mockHttpContextAccessor.Setup(x => x.HttpContext.RequestServices) .Returns(serviceCollection.BuildServiceProvider()); string foo = null; var sut = new TenantMiddleware(next: (innerHttpContext) => { //do something in next request delegate foo = "executed"; return(Task.CompletedTask); }, new ContainerBuilder(_tenants, serviceCollection)); await sut.Invoke(mockHttpContextAccessor.Object.HttpContext); Assert.Equal("executed", foo); }
public async Task TenantSpecificServices_ShouldBeInjected() { //setup IHttpContextAccessor var mockHttpContextAccessor = new Mock <IHttpContextAccessor>(); var mockHttpRequest = new Mock <HttpRequest>(); mockHttpRequest.Setup(_ => _.Headers) .Returns(new HeaderDictionary { { "tenantId", "2" } }); mockHttpContextAccessor.Setup(x => x.HttpContext.Request) .Returns(mockHttpRequest.Object); //setup serviceCollection var masterServiceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); foreach (var tenant in _tenants) { if (tenant.Id == 1) { masterServiceCollection.AddTenantScoped(tenant, typeof(IFooService), typeof(SpecialFooService), ServiceLifetime.Scoped); } else { masterServiceCollection.AddTenantScoped(tenant, typeof(IFooService), typeof(DefaultFooService), ServiceLifetime.Scoped); } //this singleton is tenant scoped. //there will be a singleton for each tenant masterServiceCollection.AddTenantScoped(tenant, typeof(IBarService), typeof(BarService), ServiceLifetime.Singleton); } masterServiceCollection.AddSingleton <ITenantProvider, MockTenantProvider>(); masterServiceCollection.AddSingleton <ITenantResolutionStrategy, HeaderTenantResolutionStrategy>(); masterServiceCollection.AddSingleton <IBazService, BazService>(); masterServiceCollection.AddSingleton(mockHttpContextAccessor.Object); mockHttpContextAccessor.Setup(x => x.HttpContext.RequestServices) .Returns(masterServiceCollection.BuildServiceProvider()); var sut = new TenantMiddleware(next: (innerHttpContext) => { var fooService = innerHttpContext.RequestServices.GetService <IFooService>(); Assert.NotNull(fooService); Assert.IsType <DefaultFooService>(fooService); return(Task.CompletedTask); }, new ContainerBuilder(_tenants, masterServiceCollection)); await sut.Invoke(mockHttpContextAccessor.Object.HttpContext); }
public void GetRequiredService_FactoryOfOneArgForInterfaceOfRegisteredType_ShouldThrow() { var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); serviceCollection.AddTransient <TestServiceOneParam <string> >(); serviceCollection.AddFactoryFacility(); var serviceProvider = serviceCollection.BuildServiceProvider(); Func <IFactory <string, ITestInterfaceOneParam <string> > > factory = () => serviceProvider.GetRequiredService <IFactory <string, ITestInterfaceOneParam <string> > >(); factory.Should().Throw <InvalidOperationException>() .WithMessage($"Unable to resolve service for type '{typeof(ITestInterfaceOneParam<string>)}' while attempting to activate '{typeof(IFactory<string, ITestInterfaceOneParam<string>>)}'."); }
public void New_FactoryOfOneArgForRegisteredInterface_ShouldSucceed() { var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); serviceCollection.AddTransient <ITestInterfaceOneParam <string>, TestServiceOneParam <string> >(); serviceCollection.AddFactoryFacility(); var serviceProvider = serviceCollection.BuildServiceProvider(); var factory = serviceProvider.GetRequiredService <IFactory <string, ITestInterfaceOneParam <string> > >(); factory.New("a").Arg.Should().Be("a"); factory.New("b").Arg.Should().Be("b"); }
public void GetRequiredService_FactoryOfOneArgForTypeWithTwoMatchingConstructors_ShouldThrow() { var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); serviceCollection.AddTransient <TwoConstructors>(); serviceCollection.AddFactoryFacility(); var serviceProvider = serviceCollection.BuildServiceProvider(); Func <IFactory <int, TwoConstructors> > factory = () => serviceProvider.GetRequiredService <IFactory <int, TwoConstructors> >(); factory.Should().Throw <InvalidOperationException>() .WithMessage($"In order to resolve a parameterised factory for service type '{typeof(TwoConstructors)}', the implementation type '{typeof(TwoConstructors)}' must contain just one constructor whose last parameter is assignable from the factory argument type '{typeof(int)}'."); }
public void GetRequiredService_TwoConstructorsServicesRegisteredForNeither_ShouldThrow() { var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); serviceCollection.AddTransient <TwoConstructors>(); var serviceProvider = serviceCollection.BuildServiceProvider(); Func <TwoConstructors> factory = () => serviceProvider.GetRequiredService <TwoConstructors>(); // This is actually checking already built-in behaviour, but illustrates the kind of exception thrown which we want to align with here factory.Should().Throw <InvalidOperationException>() .WithMessage($"No constructor for type '{typeof(TwoConstructors)}' can be instantiated using services from the service container and default values."); }
public void GetRequiredService_FactoryOfOneArgForTypeRegisteredAsNonTransient_ShouldThrow() { var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); serviceCollection.AddScoped <TestServiceOneParam <string> >(); serviceCollection.AddFactoryFacility(); var serviceProvider = serviceCollection.BuildServiceProvider(); Func <IFactory <string, TestServiceOneParam <string> > > factory = () => serviceProvider.GetRequiredService <IFactory <string, TestServiceOneParam <string> > >(); factory.Should().Throw <InvalidOperationException>() .WithMessage($"In order to resolve a parameterised factory for service type '{typeof(TestServiceOneParam<string>)}', the implementation type '{typeof(TestServiceOneParam<string>)}' must be registered with Transient lifestyle."); }
public void RequestExecutionService_2_Test() { var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); services.AddRequestPipe(); using (var serviceProviderRoot = services.BuildServiceProvider()) { using (var scope = serviceProviderRoot.CreateScope()) { var serviceProviderScope = scope.ServiceProvider; var sut = serviceProviderScope.GetRequiredService <IRequestExecutionService>(); Assert.NotNull(sut); } } }
public void New_FactoryOfOneArgOfAssignableType_ShouldSucceed() { var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); serviceCollection.AddTransient <TestServiceOneParam <IEnumerable <string> > >(); serviceCollection.AddFactoryFacility(); var serviceProvider = serviceCollection.BuildServiceProvider(); var factory = serviceProvider.GetRequiredService <IFactory <string[], TestServiceOneParam <IEnumerable <string> > > >(); factory.New(new[] { "a" }).Arg.Single().Should().Be("a"); factory.New(new[] { "b" }).Arg.Single().Should().Be("b"); }
public static async Task Main(string[] args) { var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); ConfigureServices(services); var provider = services.BuildServiceProvider(); var app = provider.GetService <Application>(); await app.StartPhoneVerificationAsync("1", "5551234567"); // await app.CheckPhoneVerificationAsync("1", "5551234567", "6494"); }
public void GetRequiredService_FactoryOfTwoArgsForTypeWithWrongConstructor_ShouldThrow() { var serviceCollection = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); serviceCollection.AddTransient <WrongConstructor>(); serviceCollection.AddFactoryFacility(); var serviceProvider = serviceCollection.BuildServiceProvider(); Func <IFactory <string, double, WrongConstructor> > factory = () => serviceProvider.GetRequiredService <IFactory <string, double, WrongConstructor> >(); factory.Should().Throw <InvalidOperationException>() .WithMessage($"In order to resolve a parameterised factory for service type '{typeof(WrongConstructor)}', the implementation type '{typeof(WrongConstructor)}' must contain a constructor whose last 2 parameters are assignable from the factory argument types '{typeof(string)}', '{typeof(double)}'."); }
public static ServiceProvider CreateServiceProvider(Action <IServiceCollection> addServices) { var services = new Microsoft.Extensions.DependencyInjection.ServiceCollection(); services.AddLogging((loggingBuilder) => { loggingBuilder.AddDebug(); }); if (addServices != null) { addServices(services); } return(services.BuildServiceProvider(true)); }
private IServiceCollection SetupRegisteredManager(string policyName = null) { var serviceCollection = new ServiceCollectionImpl(); var manager = new CircuitBreakerManager(); if (!string.IsNullOrEmpty(policyName)) { manager.TryAdd(policyName, GetCircuitBreakerPolicy()); } serviceCollection.AddSingleton <ICircuitBreakerManager>(manager); return(serviceCollection); }