/// <summary>
/// Extension with key parameter.
/// </summary>
/// <param name="ServiceProvider"></param>
/// <param name="typeService">Type</param>
/// <param name="key">Key</param>
/// <returns>The object or default.</returns>
public static object GetService(this ServiceProvider ServiceProvider, Type typeService, string key)
{
IEnumerable <object> typesList = ServiceProvider.GetServices(typeService);
object objectServiceSearch = InjectionFactory.GetValueOrDefault(key);
return(typesList.Where(x => x.GetType().Equals(objectServiceSearch)).FirstOrDefault());
}
public InjectionFactoryTests()
{
_container = Substitute.For <IContainer>();
_container.GetInstance <object>().Returns(new object());
_sut = new InjectionFactory <object>(_container);
}
public static void RegisterComponents()
{
var container = new UnityContainer();
var locator = new UnityServiceLocator(container);
ServiceLocator.SetLocatorProvider(() => locator);
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
container.RegisterType <UserService>();
container.RegisterType <StudentService>();
container.RegisterType <StudentSubjectService>();
////NHIBERNATE
//container.RegisterType<DataAccess.Nhibernate.UnitOfWork>(new PerRequestLifetimeManager());
//var factoryNH = new InjectionFactory(x => x.Resolve<DataAccess.Nhibernate.UnitOfWork>());
//container.RegisterType<IUnitOfWork>(factoryNH);
//container.RegisterType<IRepository<User>, DataAccess.Nhibernate.Repository<User>>();
//container.RegisterType<IRepository<Student>, DataAccess.Nhibernate.Repository<Student>>();
//container.RegisterType<IRepository<StudentSubject>, DataAccess.Nhibernate.Repository<StudentSubject>>();
//container.RegisterType<IRepository<Subject>, DataAccess.Nhibernate.Repository<Subject>>();
//ENTITY FRAMEWORK
container.RegisterType <DataAccess.EntityFramework.UnitOfWork>(new PerRequestLifetimeManager());
var factoryEF = new InjectionFactory(x => x.Resolve <DataAccess.EntityFramework.UnitOfWork>());
container.RegisterType <IUnitOfWork>(factoryEF);
container.RegisterType <IRepository <User>, DataAccess.EntityFramework.Repository <User> >();
container.RegisterType <IRepository <Student>, DataAccess.EntityFramework.Repository <Student> >();
container.RegisterType <IRepository <StudentSubject>, DataAccess.EntityFramework.Repository <StudentSubject> >();
container.RegisterType <IRepository <Subject>, DataAccess.EntityFramework.Repository <Subject> >();
}
public void V1_通過驗證且不是Admin角色()
{
var calculation = InjectionFactory.Create();
Action action = () => { calculation.Execute(1, 1); };
action.ShouldThrow <Exception>().WithMessage("*Admin*");
}
public void ConfigureServices(IServiceCollection services)
{
InjectionFactory.ConfigureAPI(services, Configuration);
var mappingConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new MappingProfiler());
});
IMapper mapper = mappingConfig.CreateMapper();
services.AddSingleton(mapper);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_3_0);
services.AddSwaggerGen(s =>
{
s.SwaggerDoc("v1", new OpenApiInfo
{
Version = "v1",
Title = "Casa dos Cupons",
Description = "API para controle de cupons de desconto.",
Contact = new OpenApiContact {
Name = "Matheus Chielle", Email = "*****@*****.**"
}
});
});
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequestMessage req, TraceWriter log)
{
var employeesDataProvider = InjectionFactory.GetIEmployeeDataProvider();
var httpResponseCreator = InjectionFactory.GetIHttpResponseCreator();
var employees = await employeesDataProvider.GetEmployees();
return(httpResponseCreator.CreateHttpResponse(req, HttpStatusCode.OK, employees));
}
public void V1_通過驗證且是Admin角色_調用Execute_預期得到例外()
{
Thread.CurrentPrincipal =
new GenericPrincipal(new GenericIdentity("Administrator"),
new[] { "Admin" });
var calculation = InjectionFactory.Create();
Action action = () => { calculation.Execute(1, 1); };
action.ShouldThrow <Exception>().WithMessage("*喔喔*");
}
public void Setup()
{
_httpResponseCreator = Mock.Of <IHttpResponseCreator>();
_employeeDataProvider = Mock.Of <IEmployeeDataProvider>();
_traceWriter = new TraceWriterFake();
InjectionFactory.UseIHttpResponseCreator(_httpResponseCreator);
InjectionFactory.UseIEmployeeDataProvider(_employeeDataProvider);
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
var employeeDataProvider = InjectionFactory.GetIEmployeeDataProvider();
var httpResponseCreator = InjectionFactory.GetIHttpResponseCreator();
var newEmployee = await req.Content.ReadAsAsync <Employee>();
await employeeDataProvider.AddEmployee(newEmployee);
return(httpResponseCreator.CreateHttpResponse(req, HttpStatusCode.OK, newEmployee));
}
public static void RegisterMediaWriters(IUnityContainer container)
{
var factory = new InjectionFactory(c => new Func <string, IDicomMediaWriter> (name => c.Resolve <IDicomMediaWriter>(name)));
container.RegisterType <IDicomMediaWriter, NativeMediaWriter> (MimeMediaTypes.DICOM);
container.RegisterType <IDicomMediaWriter, JsonMediaWriter> (MimeMediaTypes.Json);
container.RegisterType <IDicomMediaWriter, XmlMediaWriter> (MimeMediaTypes.xmlDicom);
container.RegisterType <IDicomMediaWriter, UncompressedMediaWriter> (MimeMediaTypes.UncompressedData);
container.RegisterType <IDicomMediaWriter, JpegMediaWriter> (MimeMediaTypes.Jpeg);
container.RegisterType <Func <string, IDicomMediaWriter> > (factory);
container.RegisterType <IDicomMediaWriterFactory, DicomMediaWriterFactory> ( );
//TODO: should not be needed when we find out why unity select a constructor that it can't build when there is a defualt
container.RegisterType <IJsonDicomConverter, JsonDicomConverter> ( );
}
/// <summary>
/// Enregistre un service distant.
/// </summary>
/// <param name="contractType">Type de l'interface représentant le contrat.</param>
public void RegisterRemoteService(Type contractType)
{
if (contractType == null)
{
throw new ArgumentNullException("contractType");
}
if (!contractType.IsInterface)
{
throw new ArgumentException("contractType " + contractType.FullName + "must define an interface.");
}
ILog log = LogManager.GetLogger("Kinetix.Application");
if (log.IsDebugEnabled)
{
log.Debug("Enregistrement du service distant " + contractType.FullName);
}
/* REMARQUE : on ne peut pas appeler HasWcfClientEndPoint à l'enregistrement car web.config n'est pas accessible. */
InterceptionPipelineEventArgs args = new InterceptionPipelineEventArgs(contractType, new List <InjectionMember> {
new Interceptor <InterfaceInterceptor>(),
new InterceptionBehavior <LogInterceptionBehavior>(),
new InterceptionBehavior <AnalyticsInterceptionBehavior>()
});
if (this.RegisteringInterceptors != null)
{
this.RegisteringInterceptors(this, args);
}
var remoteServiceFactory = new InjectionFactory(container => {
/* TODO VERSION TEMPORAIRE : il faut faire un dispose sur la factory quand le service n'est plus utilisé. */
try {
ChannelFactory factory;
var instance = GetRemoteService(contractType, out factory);
return(instance);
} catch (Exception ex) {
log.Error($"Erreur à l'instancation du service WCF distant {contractType}", ex);
throw ex;
}
});
_container.RegisterType(contractType, remoteServiceFactory);
}
public void Initialize()
{
container.RegisterType <IMyApplication, MyApplication>();
container.RegisterType <IBusinessLogic, BusinessLogic>();
container.RegisterType <IPaymentService, PayPalPaymentService>();
container.RegisterType <IWidgetRepository, CachedWidgetRepository>(new InjectionMember[] { new InjectionConstructor(new SqlWidgetRepository()) });
// http://stackoverflow.com/a/24374652/100534
var cachedRepositoryFactory = new InjectionFactory((ctr, type, str) =>
{
var genericType = type.GenericTypeArguments[0];
var sqlRepoType = typeof(SqlRepository <>).MakeGenericType(genericType);
var sqlRepoInstance = Activator.CreateInstance(sqlRepoType);
var cachedRepoType = Activator.CreateInstance(type, sqlRepoInstance);
return(cachedRepoType);
});
container.RegisterType(typeof(IRepository <>), typeof(CachedRepository <>), new InjectionMember[] { cachedRepositoryFactory });
}
private void RegisterUsersProcessor()
{
var nlogInjectionFactory = new InjectionFactory(container => GetLoggerFactory(GetAbsolutePath(UsersNlogConfigName)));
Container.RegisterType <IPrtgNLogFactory>(UsersNlogConfigName, new ContainerControlledLifetimeManager(), nlogInjectionFactory);
var assemblyType = typeof(UsersProcessor);
var logger = Container.Resolve <IPrtgNLogFactory>(UsersNlogConfigName).GetLogger(assemblyType);
var prtgErrorsHandler = new PrtgErrorsHandler(Container.Resolve <IPrtgNLogFactory>(UsersNlogConfigName));
Container.RegisterType <IProcessor, UsersProcessor>(
assemblyType.Name,
new TransientLifetimeManager(),
new InjectionFactory(c => new UsersProcessor(
logger,
prtgErrorsHandler,
c.Resolve <ISchedulerCustomerCollection>(),
c.Resolve <Func <IUserSynchronizationService> >())
));
}
/// <summary>
/// Extension from Microsoft.Extensions.DependencyInjection.
/// This method auto scan all classes with the attribute,<remarks>InjectableAttribute</remarks> and put automatically in the container services.
/// </summary>
/// <example>
/// <code>
/// public interface ITest1 {}
///
/// [InjectableAttribute(typeof(ITest1))]
/// public class Class1 : ITest1{ }
///
/// [InjectableAttribute(typeof(ITest1), DependencyInjectionTypes.Scoped)]
/// public class Class1 : ITest1{ }
///
/// [InjectableAttribute(typeof(ITest1), DependencyInjectionTypes.Scoped, "myClass1")]
/// public class Class1 : ITest1{ }
/// </code>
/// </example>
/// <param name="services"></param>
/// <param name="assemblies">Assemblies list by comma, or GetEntryAssembly by default</param>
/// <returns>ISericeCollection to continue the configuration.</returns>
public static IServiceCollection ScanInjections(this IServiceCollection services, params string[] assemblies)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
InjectionFactory.Clear();
foreach (Type zclass in CoreUtils.GetListOfTypes(assemblies))
{
foreach (var injectable in zclass.GetTypeInfo().GetCustomAttributes <InjectableAttribute>())
{
foreach (var zinterface in zclass.GetTypeInfo().ImplementedInterfaces)
{
AddInjection(services, injectable.DependencyType, zinterface, zclass);
AddInternalInjection(injectable.Name, zclass);
}
}
}
return(services);
}
static void Main(string[] args)
{
var container = new UnityContainer();
// Define a custom injection factory.
// It uses reflection to create an object based on the requested generic type.
var cachedRepositoryFactory = new InjectionFactory((ctr, type, str) =>
{
var genericType = type.GenericTypeArguments[0];
var sqlRepoType = typeof(SqlRepository <>).MakeGenericType(genericType);
var sqlRepoInstance = Activator.CreateInstance(sqlRepoType);
var cachedRepoType = Activator.CreateInstance(type, sqlRepoInstance);
return(cachedRepoType);
});
// Register our fancy reflection-loving function for IRepository<>
container.RegisterType(typeof(IRepository <>), typeof(CachedRepository <>), new InjectionMember[] { cachedRepositoryFactory });
// Now use Unity to resolve something
var usesThings = container.Resolve <UsesThings>();
usesThings.ThingsRepo.Get(); // "Getting object of type 'Things'!"
usesThings.ThingsRepo.Get(); // "Using cached repository to fetch 'Things'!"
}
public override void Initialize()
{
base.Initialize();
// This method is called for each installed module on the first stage of initialization.
// Register implementations:
var injectionFactory = new InjectionFactory(c => new CustomerReviewRepository(_connectionString, new EntityPrimaryKeyGeneratorInterceptor(), _container.Resolve <AuditableInterceptor>()));
_container.RegisterType <ICustomerReviewRepository>(injectionFactory);
_container.RegisterType <ICustomerReviewService, CustomerReviewService>();
_container.RegisterType <ICustomerReviewSearchService, CustomerReviewSearchService>();
_container.RegisterType <IProductRatingRepository>(injectionFactory);
_container.RegisterType <IProductRatingService, ProductRatingService>();
_container.RegisterType <IProductRaitingCalculator, ProductRaitingCalculator>();
var eventHandlerRegistrar = _container.Resolve <IHandlerRegistrar>();
eventHandlerRegistrar.RegisterHandler <CustomerReviewChangedEvent>(async(message, token) => await _container.Resolve <CustomerReviewChangedEventHandler>().Handle(message));
// Try to avoid calling _container.Resolve<>();
}
protected void RegisterFactory <T>(InjectionFactory x, string name)
{
UnityContainer.RegisterType <T>(name, x);
}
private static void AddInternalInjection(string key, Type zclass)
{
InjectionFactory.Add(key, zclass);
}
