public ResolvableParameterType(IServiceGraph serviceGraph, IServiceEntryFactory serviceEntryFactory, ServiceDependency dependency)
{
_serviceGraph = serviceGraph;
_serviceEntryFactory = serviceEntryFactory;
_type = dependency.DependencyType;
_dependency = dependency;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var dependencies = new ServiceDependency();
dependencies.Register(services);
services.AddScoped <OperationErrorHandler>();
services.AddMvc().AddJsonOptions(options =>
{
options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
});
}
public void ShouldSetReference()
{
var dependency = new ServiceDependency();
objectFactory.Expect(x => x.GetObject("test")).Return(dependency);
var property = typeof(TestClass).GetProperty("StaticDependency");
var reference = new ReferenceInjection(property, "test");
injector.Inject(new[] { reference });
Assert.AreEqual(dependency, TestClass.StaticDependency);
}
protected override void before_each()
{
base.before_each();
service_dependencies = new List <ServiceDependency>();
dependency_1_monitor = Substitute.For <IMonitor>();
dependency_1_monitor.Info.Returns(new MonitorInfo("FakeDb", "Database", "Db1", "Db2"));
dependency_2_monitor = Substitute.For <IMonitor>();
dependency_2_monitor.Info.Returns(new MonitorInfo("FakeQueue", "Queue", "Queue1", "Queue3", "Queue4"));
service_dependency_1 = new ServiceDependency(dependency_1_monitor);
service_dependency_2 = new ServiceDependency(dependency_2_monitor);
service_monitor = null;
overall_availability = null;
the_status = new ServiceMonitor.Status();
}
/// <summary>
/// Entry Point for initialization and route registering
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
static async Task Main(string[] args)
{
var app = WebApplication.Create(args);
ServiceDependency.Init();
var receiver = ServiceDependency.InternalServiceProvider.GetService <IReceiver>();
var observable = ServiceDependency.InternalServiceProvider.GetService <IEventObserver>();
var subscriber = ServiceDependency.InternalServiceProvider.GetService <ISendMessage>();
subscriber.Subscribe(observable);
await receiver.StartReader();
app.MapPost("/receiver", async http =>
{
var request = await http.Request.ReadJsonAsync <SNSRequest>();
await receiver.Accept(request);
http.Response.StatusCode = StatusCodes.Status200OK;
});
await app.RunAsync();
}
static void Main(string[] args)
{
var services = ServiceDependency.ConfigureServices();
var serviceProvider = services.BuildServiceProvider();
var rc = HostFactory.Run(x =>
{
x.Service <Startable>(s =>
{
s.ConstructUsing(name => serviceProvider.GetService <Startable>());
s.WhenStarted(tc => tc.Start());
s.WhenStopped(tc => tc.Stop());
});
x.RunAsLocalSystem();
x.SetDescription("Windows Service Demo");
x.SetDisplayName("WinServiceDemo");
x.SetServiceName("WinServiceDemo");
});
var exitCode = (int)Convert.ChangeType(rc, rc.GetTypeCode());
Environment.ExitCode = exitCode;
}
private void ContainerConfiguration()
{
var servicesContainer = new ServiceDependency();
_services = servicesContainer.Register(_serviceCollections);
}
public ServiceEntry CreateServiceEntry(ServiceDependency dependency)
{
return new ServiceEntry(dependency.DependencyType, LifestyleType.Override, dependency.Key);
}
public IResolvableType FindResolvableType(ServiceDependency dependency)
{
return new ResolvableParameterType(_serviceGraph, _serviceEntryFactory, dependency);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
RepositoryDependency.AllDependency(services, Configuration);
ServiceDependency.AllDependency(services, Configuration);
services.AddControllers();
}
private static void Register(ContainerBuilder containerBuilder)
{
RepositoryDependency.Register(containerBuilder);
ServiceDependency.Register(containerBuilder);
}
public IResolvableType CreateResolvableType(ServiceDependency dependency)
{
return new ResolvableParameterType(_containerServices.ServiceGraph, _containerServices.ServiceEntryFactory, dependency);
}
public ResolvableParameterType(IServiceGraph serviceGraph, IServiceEntryFactory serviceEntryFactory, ServiceDependency dependency)
: base(serviceGraph, serviceEntryFactory, dependency.DependencyType)
{
_dependency = dependency;
}
