public void ConstructorSetsInternalDataContextToTheValueOfThePassedInObject()
{
// Arrange
var mockContext = new Mock<IDataContext>();
// Act
var factory = new ServiceProviderFactory(mockContext.Object);
// Assert
Assert.AreEqual(mockContext.Object, factory.DataContext);
}
/// <summary>
/// 以dto的形式调用服务
/// </summary>
/// <param name="serviceName"></param>
/// <param name="fillArg"></param>
/// <returns></returns>
public static DTObject Invoke(string serviceName, Action <DTObject> fillArg)
{
var arg = DTObject.CreateReusable();
if (fillArg != null)
{
fillArg(arg);
}
ServiceRequest request = new ServiceRequest(serviceName, DTObject.Empty, arg);
var provider = ServiceProviderFactory.Create(request);
return(provider.Invoke(request));
}
public void GetProjectServicesReturnsInstanceOfProjectServicesUsingTheInternalDataContext()
{
// Arrange
var mockContext = new Mock<IDataContext>();
// Act
var factory = new ServiceProviderFactory(mockContext.Object);
var service = factory.GetProjectServices();
// Assert
Assert.IsInstanceOf<ProjectServices>(service);
Assert.AreEqual(mockContext.Object, ((ProjectServices)service).DataContext);
}
public void CanResolve()
{
var serCol = new ServiceCollection();
serCol.AddSingleton <IA, A>();
var factory = new ServiceProviderFactory();
var defCol = factory.CreateBuilder(serCol);
var usp = (IUnityAddonSP)factory.CreateServiceProvider(defCol);
Assert.True(usp.CanResolve(typeof(IA)));
Assert.True(usp.CanResolve(typeof(IEnumerable <IA>)));
Assert.False(usp.CanResolve(typeof(A)));
}
static async Task Main(string[] args)
{
var serviceProvider = new ServiceProviderFactory().Generate();
var gerenciador = serviceProvider.GetService <IGerenciadorService>();
var ordemExecucao = new Dictionary <ETipoDado, IAnaliseService>
{
{ ETipoDado.Cliente, new ClientesAnaliseService() },
{ ETipoDado.Vendedor, new VendedoresAnaliseService() },
{ ETipoDado.Venda, new VendasAnaliseService() },
};
await gerenciador.ExecutarProcesso(ordemExecucao);
}
public void Enumerable()
{
var serCol = new ServiceCollection();
serCol.AddSingleton <IEnum, E1>();
serCol.AddSingleton <IEnum, E2>();
var factory = new ServiceProviderFactory();
var defCol = factory.CreateBuilder(serCol);
var usp = (IUnityAddonSP)factory.CreateServiceProvider(defCol);
Assert.Equal(usp.GetService <IEnumerable <IEnum> >(), new IEnum[] { usp.GetService <IEnum>("E1"), usp.GetService <IEnum>("E2") });
Assert.IsType <IEnum[]>(usp.GetService <IEnumerable <IEnum> >());
}
public void NoArgCtor()
{
var choice = 0;
var serCol = new ServiceCollection();
serCol.AddSingleton <Service>();
var sp = serCol.BuildServiceProvider();
var factory = new ServiceProviderFactory();
var defCol = factory.CreateBuilder(serCol);
var usp = factory.CreateServiceProvider(defCol);
Assert.Equal(choice, sp.GetRequiredService <Service>().Choice);
Assert.Equal(choice, usp.GetRequiredService <Service>().Choice);
}
public void AmbiguousCtor()
{
var serCol = new ServiceCollection();
serCol.AddSingleton <Service>();
serCol.AddSingleton <IA, A>();
serCol.AddSingleton <IB, B>();
serCol.AddSingleton <IC, C>();
var factory = new ServiceProviderFactory();
var defCol = factory.CreateBuilder(serCol);
var ex = Assert.Throws <BeanCreationException>(() => factory.CreateServiceProvider(defCol));
Assert.Equal("Ambiguous constructors are found\r\n- Void .ctor(UnityAddon.CoreTest.Bean.Mocks.ConstructorResolver.IA, UnityAddon.CoreTest.Bean.Mocks.ConstructorResolver.IB)\r\n- Void .ctor(UnityAddon.CoreTest.Bean.Mocks.ConstructorResolver.IA, UnityAddon.CoreTest.Bean.Mocks.ConstructorResolver.IC)", ex.Message);
}
public void IsRegistered()
{
var serCol = new ServiceCollection();
serCol.AddSingleton <IA, A>();
var factory = new ServiceProviderFactory();
var defCol = factory.CreateBuilder(serCol);
var usp = (IUnityAddonSP)factory.CreateServiceProvider(defCol);
Assert.True(usp.IsRegistered(typeof(IA)));
Assert.True(usp.IsRegistered(typeof(IA), "A"));
Assert.False(usp.IsRegistered(typeof(A)));
Assert.False(usp.IsRegistered(typeof(IA), "B"));
}
public void GetAllServices()
{
var serCol = new ServiceCollection();
serCol.AddSingleton <IA, A>();
serCol.AddSingleton <IA, A2>();
var factory = new ServiceProviderFactory();
var defCol = factory.CreateBuilder(serCol);
var usp = (IUnityAddonSP)factory.CreateServiceProvider(defCol);
var serAs = new IA[] { usp.GetService <IA>("A"), usp.GetService <IA>("A2") };
Assert.Equal(usp.GetServices <IA>(), serAs);
Assert.IsType <IA[]>(usp.GetServices <IA>());
}
public async Task Test()
{
try
{
var hostingEnvironment = new IntegrationTestHostingEnvironment();
var serviceProvider = new ServiceProviderFactory().Build(hostingEnvironment);
var config = hostingEnvironment.ConfigFactory();
var commandDispatcher = serviceProvider.GetService <ICommandDispatcher>();
using (var smallDataSetStream = Assembly.GetExecutingAssembly()
.GetManifestResourceStream(typeof(Basic), "small-make-model-data-set.csv"))
{
await commandDispatcher.DispatchAsync(new StoreObjectCommand
{
Key = "raw/smallDataSet.csv",
DataStream = smallDataSetStream
});
}
await serviceProvider.GetService <IQueueClient>().Enqueue(config.RawDataQueueName, "raw/smallDataSet.csv");
await commandDispatcher.DispatchAsync(new WorkerManagerCommand());
await WaitUntil(async() => (await commandDispatcher.DispatchAsync(new IsTerminatedCommand())).Result);
var finalObjectKey = serviceProvider.GetService <IQueueClient>().Dequeue(serviceProvider.GetService <IConfig>().FinalReducedQueueName).Result.First().Message;
var finalReductionResult = await commandDispatcher.GetObjectAsString(finalObjectKey);
finalReductionResult.Split(Environment.NewLine).Count(x => !string.IsNullOrEmpty(x)).ShouldBe(7);
finalReductionResult.ShouldContain("NULL,2");
finalReductionResult.ShouldContain("YAMAHA,1");
finalReductionResult.ShouldContain("MERCEDES,1");
finalReductionResult.ShouldContain("VOLKSWAGEN,1");
finalReductionResult.ShouldContain("OTHER BRITISH,1");
finalReductionResult.ShouldContain("BMW,2");
finalReductionResult.ShouldContain("FORD,1");
}
catch (Exception e)
{
Console.WriteLine(e.Demystify());
throw;
}
}
public Tests()
{
_serviceProvider = ServiceProviderFactory.GetServiceProvider(new MessageSenderConfiguration());
_stateEditor = _serviceProvider.GetService <IPandemicStateEditor>();
_playerFactory = _serviceProvider.GetService <IPlayerFactory <IPandemicTurn> >();
_sut = _playerFactory.CreatePlayers(new PlayerConfiguration {
PlayerCount = 1
}).SingleOrDefault();
_state = _serviceProvider.GetService <IPandemicState>();
_stateEditor.Clear(_state, 6);
var turnValidator = A.Fake <IPandemicActionValidator>();
_turn = new PandemicTurn(turnValidator);
}
public void OneTimeSetUp()
{
var options = OptionsParser.Populate(new GeostationaryOptions
{
Tint = "ff0000",
InterpolationType = InterpolationOptions.B,
SpatialResolution = Constants.Satellite.SpatialResolution.TwoKm,
DefinitionsPath = DefinitionsPath,
HazeAmount = 1.0f
});
// Build DI container
ServiceProvider = ServiceProviderFactory.ConfigureServices(options);
UnderlayCacheRepository.DeleteCache();
UnderlayCacheRepository.Initialise();
}
public async Task Should_resolve_dependencies_from_serviceprovider()
{
IUnityContainer container = null;
IServiceProvider serviceProvider = null;
var context = await Scenario.Define <Context>()
.WithEndpoint <EndpointWithExternallyManagedContainer>(endpointBuilder =>
{
var serviceCollection = new ServiceCollection();
// register service using the IServiceCollection API:
serviceCollection.AddSingleton <ServiceCollectionService>();
// register service using the NServiceBus container API:
endpointBuilder.CustomConfig(endpointConfiguration => endpointConfiguration
.RegisterComponents(c => c
.RegisterSingleton(new InternalApiService())));
endpointBuilder.ToCreateInstance(
configuration => Task.FromResult(EndpointWithExternallyManagedServiceProvider
.Create(configuration, serviceCollection)),
startableEndpoint =>
{
IServiceProviderFactory <IUnityContainer> factory = new ServiceProviderFactory(container);
container = factory.CreateBuilder(serviceCollection);
// register service using the container native API:
container.RegisterSingleton <NativeApiService>();
serviceProvider = factory.CreateServiceProvider(container);
return(startableEndpoint.Start(serviceProvider));
});
endpointBuilder.When(session => session.SendLocal(new TestMessage()));
})
.Done(c => c.InjectedInternalApiService != null)
.Run();
Assert.AreSame(context.InjectedNativeApiService, container.Resolve <NativeApiService>());
Assert.AreSame(context.InjectedNativeApiService, serviceProvider.GetService <NativeApiService>());
Assert.AreSame(context.InjectedInternalApiService, container.Resolve <InternalApiService>());
Assert.AreSame(context.InjectedInternalApiService, serviceProvider.GetService <InternalApiService>());
Assert.AreSame(context.InjectedServiceCollectionService, container.Resolve <ServiceCollectionService>());
Assert.AreSame(context.InjectedServiceCollectionService, serviceProvider.GetService <ServiceCollectionService>());
}
public void ShouldUseDefaultValue()
{
//My own implementation, works
// var container = new UnityContainer().WithAspNetCoreServiceProvider();
// container.Resolve<MyTestClass>();
var c = new UnityContainer();
var s1 = new ServiceCollection().AddOptions();
var s2 = new ServiceCollection().AddOptions();
s1.AddSingleton <ITest1, Test1>();
s2.AddSingleton <ITest1, Test1>();
var spf1 = new ServiceProviderFactory(c);
var spf2 = new ServiceProviderFactory(c);
var cc1 = spf1.CreateBuilder(s1);
var cc2 = spf2.CreateBuilder(s2);
var sp1 = spf1.CreateServiceProvider(cc1);
var t1 = sp1.GetRequiredService <ITest1>();
var sp2 = spf2.CreateServiceProvider(cc2);
var t2 = sp2.GetRequiredService <ITest1>();
Assert.AreNotSame(t2, t1);
// var sp =spf.CreateServiceProvider(cc);
// Assert.IsNotNull(sp.GetService<MyTestClass1>());
// var sp = cc.Resolve<IServiceProvider>();
// var ccc = cc.CreateChildContainer();
// var spp = ccc.Resolve<IServiceProvider>();
//cc.Resolve<MyTestClass>();
}
public QwerkController(string qwerkUserId, QwerkPrx qwerkProxy, TerkCommunicator communicator)
{
this.qwerkProxy = qwerkProxy;
ServiceProvider serviceProvider = ServiceProviderFactory.getFactory().createServiceProvider(qwerkUserId,
qwerkProxy,
communicator);
ServiceFactory serviceFactory = new QwerkServiceFactory(qwerkProxy);
// note: the AnalogInputsService is created differently since there isn't really a service of type
// AnalogInputsService.TYPE_ID. Currently, the only way to get analog data is from Qwerk's getState() method. So,
// we use a special service factory (QwerkServiceFactory) which has a reference to the Qwerk proxy which is used
// to create the AnalogInputsService. This hackishness will change once we fix the API to fully support all
// services (if you poke through the code, you'll see that the DigitalIOService is a bit of a hack, too).
analogInputsService = (AnalogInputsService)serviceFactory.createService(AnalogInputsService.TYPE_ID, null);
digitalIOService = (DigitalIOService)serviceProvider.getService(DigitalIOService.TYPE_ID, serviceFactory);
motorService = (MotorService)serviceProvider.getService(MotorService.TYPE_ID, serviceFactory);
servoService = (ServoService)serviceProvider.getService(ServoService.TYPE_ID, serviceFactory);
videoStreamService = (VideoStreamService)serviceProvider.getService(VideoStreamService.TYPE_ID, serviceFactory);
}
public void EnumerableWithQualifiers()
{
var factory = new ServiceProviderFactory();
var appCtx = factory.CreateBuilder();
appCtx.ServiceRegistry.AddSingleton <IEnum, E1>("A");
appCtx.ServiceRegistry.AddSingleton <IEnum, E2>("B");
appCtx.ServiceRegistry.AddSingleton <IEnum, E3>("A");
var usp = (IUnityAddonSP)factory.CreateServiceProvider(appCtx);
var beannames = usp.GetRequiredService <IBeanDefinitionContainer>().GetAllBeanDefinitions(typeof(IEnum), "A").Select(d => d.Name);
var beans = beannames.Select(n => usp.GetService <IEnum>(n)).ToArray();
Assert.IsType <E1>(beans[0]);
Assert.IsType <E3>(beans[1]);
Assert.Equal(2, beans.Length);
Assert.Equal(usp.GetService <IEnumerable <IEnum> >("A"), beans);
Assert.IsType <IEnum[]>(usp.GetService <IEnumerable <IEnum> >());
}
public void ShouldUseDefaultValue()
{
//My own implementation, works
// var container = new UnityContainer().WithAspNetCoreServiceProvider();
// container.Resolve<MyTestClass>();
var c = new UnityContainer();
var spf = new ServiceProviderFactory(c);
var cc = spf.CreateBuilder(new ServiceCollection());
// var sp =spf.CreateServiceProvider(cc);
// Assert.IsNotNull(sp.GetService<MyTestClass1>());
// var sp = cc.Resolve<IServiceProvider>();
// var ccc = cc.CreateChildContainer();
// var spp = ccc.Resolve<IServiceProvider>();
//cc.Resolve<MyTestClass>();
}
private void InvokeTestRun(TestRun testRun, TestRunExecutionContext context, TestRunResult result,
ITestRunLogger logger)
{
context.TestRun = testRun;
context.ServiceProvider = ServiceProviderFactory.Create();
OnBeforeTestRun(context);
try
{
int stepNumber = 1;
foreach (ITestRunStep testRunStep in testRun.Steps)
{
context.StepNumber = stepNumber++;
InvokeStep(testRunStep, context, result, logger);
}
}
finally
{
context.Step = null;
var disposableServiceProvider = context.ServiceProvider as IDisposable;
disposableServiceProvider?.Dispose();
OnAfterTestRun(context);
}
}
public JsonResult Play(Game game, int playCount = 1)
{
var serviceProvider = ServiceProviderFactory.GetServiceProvider(_messageSenderconfiguration);
var playerConfiguration = new PlayerConfiguration {
PlayerCount = 2
};
IGameState gameState = null;
for (var gamesPlayed = 0; gamesPlayed < playCount; gamesPlayed++)
{
switch (game)
{
case Game.Pandemic:
gameState = GameFactory.CreateGame <IPandemicState, IPandemicTurn>(serviceProvider, playerConfiguration).Play();
break;
case Game.ForSale:
gameState = GameFactory.CreateGame <IForSaleGameState, IForSaleGameTurn>(serviceProvider, playerConfiguration).Play();
break;
}
}
return(new JsonResult(gameState));;
}
private static async Task MainAsync(params string[] args)
{
//var hostingEnvironment = new AwsLambdaHostingEnvironment();
var hostingEnvironment = new CommandLineLocalHostingEnvironment();
var serviceProvider = new ServiceProviderFactory().Build(hostingEnvironment);
var config = serviceProvider.GetService <IConfig>();
foreach (var arg in args)
{
await serviceProvider.GetService <IQueueClient>().Enqueue(config.RawDataQueueName, arg);
}
var commandDispatcher = serviceProvider.GetService <IFrameworkCommandDispatcher>();
#pragma warning disable 4014
commandDispatcher.DispatchAsync(new WorkerManagerCommand());
#pragma warning restore 4014
var sw = new Stopwatch();
sw.Start();
BlockUntilJobTerminates(commandDispatcher);
sw.Stop();
System.Console.WriteLine($"That took {sw.Elapsed.TotalSeconds:0.0}s");
}
public GameController(IOptions <MessageSenderConfiguration> configuration)
{
_messageSenderconfiguration = configuration.Value;
_serviceProvider = ServiceProviderFactory.GetServiceProvider(_messageSenderconfiguration);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
await Task.Delay(100);
Console.WriteLine();
using (var scope = ServiceProviderFactory.CreateScope())
{
ILogic logic = scope.ServiceProvider.GetService <ILogic>();
Console.WriteLine($"Running {nameof(logic.RunWithNoResultNoServiceAsync)}...");
await logic.RunWithNoResultNoServiceAsync();
Console.WriteLine($"Running {nameof(logic.RunWithNoResult1ServiceAsync)}...");
await logic.RunWithNoResult1ServiceAsync();
Console.WriteLine($"Running {nameof(logic.RunWithNoResult2ServiceAsync)}...");
await logic.RunWithNoResult2ServiceAsync();
Console.WriteLine($"Running {nameof(logic.RunWithNoResult3ServiceAsync)}...");
await logic.RunWithNoResult3ServiceAsync();
Console.WriteLine($"Running {nameof(logic.RunWithNoResult4ServiceAsync)}...");
await logic.RunWithNoResult4ServiceAsync();
Console.WriteLine($"Running {nameof(logic.RunWithResultNoServiceAsync)}...");
await logic.RunWithResultNoServiceAsync();
Console.WriteLine($"Running {nameof(logic.RunWithResult1ServiceAsync)}...");
await logic.RunWithResult1ServiceAsync();
Console.WriteLine($"Running {nameof(logic.RunWithResult2ServiceAsync)}...");
await logic.RunWithResult2ServiceAsync();
Console.WriteLine($"Running {nameof(logic.RunWithResult3ServiceAsync)}...");
await logic.RunWithResult3ServiceAsync();
Console.WriteLine($"Running {nameof(logic.RunWithResult4ServiceAsync)}...");
await logic.RunWithResult4ServiceAsync();
Console.WriteLine($"Running {nameof(logic.RunWithNoResultNoService)}...");
logic.RunWithNoResultNoService();
Console.WriteLine($"Running {nameof(logic.RunWithNoResult1Service)}...");
logic.RunWithNoResult1Service();
Console.WriteLine($"Running {nameof(logic.RunWithNoResult2Service)}...");
logic.RunWithNoResult2Service();
Console.WriteLine($"Running {nameof(logic.RunWithNoResult3Service)}...");
logic.RunWithNoResult3Service();
Console.WriteLine($"Running {nameof(logic.RunWithNoResult4Service)}...");
logic.RunWithNoResult4Service();
Console.WriteLine($"Running {nameof(logic.RunWithResultNoService)}...");
logic.RunWithResultNoService();
Console.WriteLine($"Running {nameof(logic.RunWithResult1Service)}...");
logic.RunWithResult1Service();
Console.WriteLine($"Running {nameof(logic.RunWithResult2Service)}...");
logic.RunWithResult2Service();
Console.WriteLine($"Running {nameof(logic.RunWithResult3Service)}...");
logic.RunWithResult3Service();
Console.WriteLine($"Running {nameof(logic.RunWithResult4Service)}...");
logic.RunWithResult4Service();
}
Console.WriteLine();
HostApplicationLifetime.StopApplication();
}
public object FromTuple() => ServiceProviderFactory.FromTuple(new ValueTuple <IConvertible, ICloneable, IComparable>(Value, Value, Value));
public None()
{
context = ServiceProviderFactory.GetApplicationDbContext();
}
public BaseController()
{
AppServiceLocator = ServiceProviderFactory.CreateServiceProvider();
}
public object CachedProvider() => ServiceProviderFactory.Create <IConvertible, ICloneable, IComparable>(Value, Value, Value);
public static IServiceProvider UseAmbientDbConnection <TContext>(this IServiceCollection services)
where TContext : DbContext => ServiceProviderFactory.CreateServiceProvider <TContext>(services);
public TextSplitApiClientTests(TestWebApplicationFactory <Startup> factory)
{
var serviceProvider = ServiceProviderFactory.GetServiceProvider();
_client = new TextSplitApiClient(factory.CreateClient(), serviceProvider.GetService <ILogger <TextSplitApiClient> >());
}
public async Task SetupBotAsync()
{
IServiceProvider serviceProvider = new ServiceProviderFactory().BuildServiceProvider();
await serviceProvider.GetRequiredService <StartupBot>().StartBotAsync();
}
protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
{
var factory = new ServiceProviderFactory();
return(factory.CreateServiceProvider(factory.CreateBuilder(serviceCollection)));
}
public void TestChilds()
{
{
var root = new UnityContainer();
root.RegisterType <AFactory>(new ContainerControlledLifetimeManager());
root.RegisterType <IAFactory, AFactory>();
var first = root.Resolve <IAFactory>();
var second = root.Resolve <IAFactory>();
Assert.AreEqual(first, second);
var child = root.CreateChildContainer();
var third = child.Resolve <IAFactory>();
Assert.AreEqual(first, third);
}
// third.Disposed = true;
{
var root = new UnityContainer();
root.RegisterType <AFactory>(new ContainerControlledLifetimeManager());
root.RegisterType <IAFactory, AFactory>();
var child1 = root.CreateChildContainer();
var first = child1.Resolve <IAFactory>();
var child2 = root.CreateChildContainer();
var second = child2.Resolve <IAFactory>();
Assert.AreEqual(first, second);
child1.Dispose();
global::Unity.Microsoft.DependencyInjection.ServiceProvider.ConfigureServices(new ServiceCollection());
}
{
var root = new UnityContainer();
root.RegisterType <AFactory>(new ContainerControlledLifetimeManager());
root.RegisterType <IAFactory, AFactory>();
var fac = new ServiceProviderFactory(root);
var child = fac.CreateBuilder(new ServiceCollection());
var sp = fac.CreateServiceProvider(child);
sp.GetRequiredService <IAFactory>();
if (sp is IDisposable dis)
{
dis.Dispose();
}
var first = root.Resolve <IAFactory>();
var second = root.Resolve <IAFactory>();
Assert.AreEqual(first, second);
}
{
var test = new UnityContainer();
}
}
