private IMediator BuildMediator()
{
var services = new ServiceCollection();
DIHelper.ConfigureServices(services);
services.AddDbContext <IDbContext, AppDbContext>(options =>
options.UseInMemoryDatabase(Guid.NewGuid().ToString()));
var serviceProviderFactory = new AutofacServiceProviderFactory();
var containerBuilder = serviceProviderFactory.CreateBuilder(services);
var serviceProvider = serviceProviderFactory.CreateServiceProvider(containerBuilder);
var mediator = serviceProvider.GetRequiredService <IMediator>();
var dbContext = serviceProvider.GetRequiredService <IDbContext>();
dbContext.Orders.AddRange(
new Order {
Id = 1, UserEmail = "*****@*****.**"
},
new Order {
Id = 2, UserEmail = "other_email"
});
dbContext.SaveChangesAsync().Wait();
return(mediator);
}
public static IHostBuilder UseClaptrap(this IHostBuilder hostBuilder,
Action <IClaptrapBootstrapperBuilder> builderAction,
Action <ContainerBuilder>?containerBuilderAction = null)
{
return(hostBuilder
.ConfigureServices((context, collection) =>
{
var configSection =
context.Configuration.GetSection(ClaptrapServerOptions.ConfigurationSectionName);
collection.Configure <ClaptrapServerOptions>(configSection);
})
.UseServiceProviderFactory(context =>
{
var serviceProviderFactory = new AutofacServiceProviderFactory(
builder =>
{
var collection = new ServiceCollection().AddLogging(logging =>
{
logging.SetMinimumLevel(LogLevel.Debug);
});
var buildServiceProvider = collection.BuildServiceProvider();
var loggerFactory = buildServiceProvider.GetService <ILoggerFactory>();
var bootstrapperBuilder = new AutofacClaptrapBootstrapperBuilder(loggerFactory, builder);
bootstrapperBuilder
.ScanClaptrapModule()
.AddConfiguration(context);
builderAction.Invoke(bootstrapperBuilder);
var claptrapBootstrapper = bootstrapperBuilder.Build();
claptrapBootstrapper.Boot();
containerBuilderAction?.Invoke(builder);
});
return serviceProviderFactory;
}));
}
protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
{
var factory = new AutofacServiceProviderFactory();
var builder = factory.CreateBuilder(serviceCollection);
return(factory.CreateServiceProvider(builder));
}
public IHost Build()
{
this.ConfigureServices(y => y.AddSingleton(this.StartupHandler));
this.StartupHandler.ConfigureServices(this.serviceDescriptors);
this.InvokeConfigureServiceActions();
var serviceProviderFactory = new AutofacServiceProviderFactory(builder => builder.Populate(this.serviceDescriptors));
this.hostBuilder
.UseWindowsService()
.ConfigureLogging(cfg =>
{
cfg.AddFilter("Microsoft.EntityFrameworkCore", LogLevel.Warning);
cfg.AddFilter("Hangfire", LogLevel.Error);
})
.UseServiceProviderFactory(serviceProviderFactory)
.ConfigureAppConfiguration(cfg =>
{
cfg.Sources.Clear();
cfg.AddConfiguration(Globals.DefaultConfiguration);
});
var host = this.hostBuilder.Build();
this.StartupHandler.Configure(host.Services.GetService <IServiceProvider>());
return(host);
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseServiceProviderFactory(context =>
{
var serviceProviderFactory = new AutofacServiceProviderFactory(
builder =>
{
var clientBuilder = new ClientBuilder();
clientBuilder
.UseLocalhostClustering()
#if !DEBUG
.UseConsulClustering(options =>
{
options.Address =
new Uri(context.Configuration["Claptrap:Orleans:Clustering:ConsulUrl"]);
})
#endif
.ConfigureApplicationParts(manager =>
manager.AddFromDependencyContext().WithReferences())
;
var clusterClient = clientBuilder.Build();
builder.RegisterInstance(clusterClient)
.As <IGrainFactory>()
.As <IClusterClient>()
.SingleInstance()
.ExternallyOwned();
});
return(serviceProviderFactory);
})
.ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup <Startup>(); });
public static IServiceProvider CreateBuilder(string[] args)
{
var config = new ConfigurationBuilder()
.SetBasePath(System.IO.Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.Build();
var services = new ServiceCollection()
.AddLogging(loggingBuilder =>
{
loggingBuilder.ClearProviders();
loggingBuilder.SetMinimumLevel(LogLevel.Trace);
loggingBuilder.AddNLog(config);
});
var factory = new AutofacServiceProviderFactory();
var startup = new Startup(config);
startup.ConfigureServices(services);
var builder = factory.CreateBuilder(services);
startup.ConfigureContainer(builder);
var provider = factory.CreateServiceProvider(builder);
return(provider);
}
public static ContainerBuilder BuildContainer(IServiceCollection services)
{
var factory = new AutofacServiceProviderFactory();
var cb = factory.CreateBuilder(services);
return(cb);
}
static AppFixture()
{
_configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.AddEnvironmentVariables()
.Build();
var startup = new Startup(_configuration, new HostEnvironment());
var services = new ServiceCollection();
startup.ConfigureServices(services);
var builder = new AutofacServiceProviderFactory().CreateBuilder(services);
startup.ConfigureContainer(builder);
builder.RegisterType <NullDispatcher>().As <IDomainEventDispatcher>(); // replace with null dispatcher
var container = builder.Build();
_scopeFactory = container.Resolve <IServiceScopeFactory>();
_checkpoint = new Checkpoint
{
DbAdapter = DbAdapter.Postgres,
TablesToIgnore = new[]
{
"unit_of_measure_lib",
"migration_history"
}
};
ConnectionString = _configuration.GetConnectionString("Postgres");
Debug.Assert(ConnectionString.Contains("_test"));
}
public IServiceProvider GetServiceProvider()
{
var env = new TestWebHostEnviroment();
env.EnvironmentName = "development";
var services = new ServiceCollection();
var configBuilder = new ConfigurationBuilder();
JsonConfigurationExtensions.AddJsonFile(configBuilder, "appsettings.json", true, true);
Configuration = configBuilder.Build();
services.AddLogging(builder =>
{
builder.ClearProviders();
if (env.EnvironmentName.Contains("develop", StringComparison.OrdinalIgnoreCase))
{
//分环境不同来配置log
}
builder.AddDebug();
builder.AddConsole();
builder.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
});
var startUp = new Startup(Configuration, env);
startUp.ConfigureServices(services);
var autofacServiceProviderFactory = new AutofacServiceProviderFactory(startUp.ConfigureContainer);
var containerBuilder = autofacServiceProviderFactory.CreateBuilder(services);
return(autofacServiceProviderFactory.CreateServiceProvider(containerBuilder));
}
public static WebAssemblyHostBuilder CreateHostBuilder(string[] args)
{
var builder = WebAssemblyHostBuilder.CreateDefault();
builder.RootComponents.Add <App>("app");
var factory = new AutofacServiceProviderFactory(b => b.RegisterModule <ClientModule>());
builder.ConfigureContainer(factory);
var services = builder.Services;
services.AddOptions();
services.AddBlazoredLocalStorage();
services.AddAuthorizationCore(config =>
{
config.AddPolicy(Policies.HasWeather, Policies.WeatherPolicy());
config.AddPolicy(Policies.HasQuotes, Policies.QuotesPolicy());
});
JobManager.UseUtcTime();
return(builder);
}
private static ContainerBuilder BuildContainer(IServiceCollection services)
{
var factory = new AutofacServiceProviderFactory();
var result = factory.CreateBuilder(services);
return(result);
}
public BitServiceProviderFactory(Action <IDependencyManager, IServiceCollection, ContainerBuilder> configureAction)
{
_inner = new AutofacServiceProviderFactory(containerBuilder =>
{
if (_services == null)
{
throw new InvalidOperationException("services is null");
}
if (containerBuilder == null)
{
throw new InvalidOperationException("containerBuilder is null");
}
containerBuilder.Properties["services"] = _services;
AutofacDependencyManager dependencyManager = new AutofacDependencyManager();
dependencyManager.UseContainerBuilder(containerBuilder);
((IServiceCollectionAccessor)dependencyManager).ServiceCollection = _services;
containerBuilder.Properties["dependencyManager"] = dependencyManager;
containerBuilder.Register(c => _container).SingleInstance();
configureAction?.Invoke(dependencyManager, _services, containerBuilder);
});
}
protected override void OnCreate(Bundle bundle)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(bundle);
Rg.Plugins.Popup.Popup.Init(this, bundle);
Forms.Init(this, bundle);
// Initializing FFImageLoading
CachedImageRenderer.Init(false);
// Initializing User Dialogs
UserDialogs.Init(this);
// Initializing Xamarin Essentials
Xamarin.Essentials.Platform.Init(this, bundle);
#if GORILLA
LoadApplication(UXDivers.Gorilla.Droid.Player.CreateApplication(
this,
new UXDivers.Gorilla.Config("Good Gorilla")
.RegisterAssemblyFromType <InverseBooleanConverter>()
.RegisterAssemblyFromType <CachedImageRenderer>()));
#else
//Loading dependent libindy
JavaSystem.LoadLibrary("gnustl_shared");
JavaSystem.LoadLibrary("indy");
// Initializing QR Code Scanning support
ZXing.Net.Mobile.Forms.Android.Platform.Init();
//Marshmellow and above require permission requests to be made at runtime
if ((int)Build.VERSION.SdkInt >= 23)
{
CheckAndRequestRequiredPermissions();
}
var services = new ServiceCollection(); //Create a service collection
services.AddHttpClient(); //invoke add http client extension
services.AddOptions();
//...add other services as needed
//use autofac integration `Autofac.Extensions.DependencyInjection`
var providerFactory = new AutofacServiceProviderFactory();
//OR Container
ContainerBuilder builder = providerFactory.CreateBuilder(services);
builder.RegisterModule(new PlatformModule());
var container = builder.Build();
LoadApplication(new App(container));
#endif
}
public void CreateBuilderExecutesConfigurationActionWhenProvided()
{
var factory = new AutofacServiceProviderFactory(config => config.Register(c => "Foo"));
var builder = factory.CreateBuilder(new ServiceCollection());
Assert.Equal("Foo", builder.Build().Resolve <string>());
}
/// <inheritdoc />
public override void OnInitialize(TestRunExecutionContext context)
{
var builder = new ContainerBuilder();
DiConfig.Setup(builder, testingMode: true);
container = builder.Build();
ServiceProviderFactory = new AutofacServiceProviderFactory(container);
}
public void CreateServiceProviderReturnsAutofacServiceProvider()
{
var factory = new AutofacServiceProviderFactory();
var serviceProvider = factory.CreateServiceProvider(new ContainerBuilder());
Assert.IsType <AutofacServiceProvider>(serviceProvider);
}
public void CreateBuilderReturnsNewInstance()
{
var factory = new AutofacServiceProviderFactory();
var builder = factory.CreateBuilder(new ServiceCollection());
Assert.NotNull(builder);
}
public void CreateServiceProviderThrowsWhenProvidedNullContainerBuilder()
{
var factory = new AutofacServiceProviderFactory();
var exception = Assert.Throws <ArgumentNullException>(() => factory.CreateServiceProvider(null));
Assert.Equal("containerBuilder", exception.ParamName);
}
public void CreateBuilderAllowsForNullConfigurationAction()
{
var factory = new AutofacServiceProviderFactory();
var builder = factory.CreateBuilder(new ServiceCollection());
Assert.NotNull(builder);
}
public static AutofacServiceProviderFactory AddAutofacServiceProviderFactory(this IServiceCollection services, ContainerBuilder containerBuilder)
{
var factory = new AutofacServiceProviderFactory(containerBuilder);
services.AddObjectAccessor(containerBuilder);
services.AddSingleton((IServiceProviderFactory <ContainerBuilder>)factory);
return(factory);
}
public FakeAutofacServiceProviderFactory(
ContainerBuildOptions containerBuildOptions = ContainerBuildOptions.None,
Action <ContainerBuilder>?configurationActionOnBefore = null,
Action <ContainerBuilder>?configurationActionOnAfter = null)
{
_configurationActionOnAfter = configurationActionOnAfter;
AutofacServiceProviderFactory =
new AutofacServiceProviderFactory(containerBuildOptions, configurationActionOnBefore);
}
private void InitApi()
{
ContainerBuilder builder = new AutofacServiceProviderFactory().CreateBuilder(new ServiceCollection().AddHttpClient());
builder.RegisterType <BlizzardApiReader>().As <IBlizzardApiReader>();
builder.RegisterType <ApiWebClient>().As <IWebClient>();
builder.Register(c => Options.Create(Configuration.GetSection("BlizzardApi").Get <BlizzardApiConfiguration>())).As <IOptions <BlizzardApiConfiguration> >();
Api = builder.Build().Resolve <IBlizzardApiReader>();
}
public void CreateServiceProviderUsesDefaultContainerBuildOptionsWhenNotProvided()
{
var factory = new AutofacServiceProviderFactory();
var services = new ServiceCollection().AddSingleton("Foo");
var builder = factory.CreateBuilder(services);
var serviceProvider = factory.CreateServiceProvider(builder);
Assert.NotNull(serviceProvider.GetService <Lazy <string> >());
}
public void CreateServiceProviderBuildsServiceProviderUsingContainerBuilder()
{
var factory = new AutofacServiceProviderFactory();
var services = new ServiceCollection().AddTransient <object>();
var builder = factory.CreateBuilder(services);
var serviceProvider = factory.CreateServiceProvider(builder);
Assert.NotNull(serviceProvider.GetService(typeof(object)));
}
protected void Application_Start()
{
var services = new ServiceCollection();
services.AddDistributedMemoryCache(); //Token cache için gerekli
services.AddePlatformClients(clientOptions =>
{
clientOptions.AuthServiceUrl = "https://coretest.isim360.com";
clientOptions.InvoiceServiceUrl = "https://efaturaservicetest.isim360.com";
clientOptions.Auth = new ClientOptions.AuthOption
{
ClientId = "serviceApi",
Username = "******",
Password = "******"
};
});
var providerFactory = new AutofacServiceProviderFactory();
//to populate your container
ContainerBuilder builder = providerFactory.CreateBuilder(services);
//var builder = new ContainerBuilder();
// MVC - Register your MVC controllers.
builder.RegisterControllers(typeof(WebApiApplication).Assembly);
// MVC - OPTIONAL: Register model binders that require DI.
builder.RegisterModelBinders(typeof(WebApiApplication).Assembly);
builder.RegisterModelBinderProvider();
// MVC - OPTIONAL: Register web abstractions like HttpContextBase.
builder.RegisterModule <AutofacWebTypesModule>();
// MVC - OPTIONAL: Enable property injection in view pages.
builder.RegisterSource(new ViewRegistrationSource());
// MVC - OPTIONAL: Enable property injection into action filters.
builder.RegisterFilterProvider();
// ePlatform Services
//builder.RegisterModule<ePlatformSerivecesModule>();
// MVC - Set the dependency resolver to be Autofac.
var container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
// Standard MVC setup:
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
private static IServiceProvider CreateServiceProvider(ServiceCollection services)
{
var autofacServiceProviderFactory =
new AutofacServiceProviderFactory(builder => builder.RegisterModule(new AutoRegistrationModule()));
services.AddSingleton <IServiceProviderFactory <ContainerBuilder> >(autofacServiceProviderFactory);
var containerBuilder = autofacServiceProviderFactory.CreateBuilder(services);
var serviceProvider = autofacServiceProviderFactory.CreateServiceProvider(containerBuilder);
return(serviceProvider);
}
internal AutoFacServiceProviderFactoryDecorator(
AssemblyPaths assemblyPaths,
Action <IDependousConfiguration> configurationBuilder = null,
Action <object> logger = null,
Action <ContainerBuilder> containerBuilder = null)
{
_assemblyPaths = assemblyPaths;
_configurationBuilder = configurationBuilder;
_logger = logger ?? ((x) => { });
_decorateer = new AutofacServiceProviderFactory(containerBuilder);
}
internal AutoFacServiceProviderFactoryDecorator(
AssemblySearchPatternFactory assemblySearchPatternFactory,
Action <IDependousConfiguration> configurationBuilder = null,
Action <object> logger = null,
Action <ContainerBuilder> containerBuilder = null)
{
_assemblySearchPatternFactory = assemblySearchPatternFactory;
_configurationBuilder = configurationBuilder;
_logger = logger;
_decorateer = new AutofacServiceProviderFactory(containerBuilder);
}
public void CreateBuilderReturnsInstanceWithServicesPopulated()
{
var factory = new AutofacServiceProviderFactory();
var services = new ServiceCollection();
services.AddTransient <object>();
var builder = factory.CreateBuilder(services);
Assert.True(builder.Build().IsRegistered <object>());
}
public void CreateServiceProviderUsesContainerBuildOptionsWhenProvided()
{
var options = ContainerBuildOptions.ExcludeDefaultModules;
var factory = new AutofacServiceProviderFactory(options);
var services = new ServiceCollection().AddSingleton("Foo");
var builder = factory.CreateBuilder(services);
var serviceProvider = factory.CreateServiceProvider(builder);
Assert.Null(serviceProvider.GetService <Lazy <string> >());
}
