public UnitOfWork(ApplicationDbContext dbContext)
{
_dbContext = dbContext;
// Each repo will share the db context:
_fooRepo = new FooRepository(_dbContext);
}
/// <summary>
/// Initializes a new instance of the <see cref="FooService"/> class.
/// </summary>
public FooService(
IFooRepository fooRepository,
IMapper mapper)
{
this._fooRepository = fooRepository;
this._mapper = mapper;
}
public void Initialize()
{
//Mock repository creation
Mock <IFooRepository> mock = new Mock <IFooRepository>();
mock.Setup(m => m.GetAll()).Returns(new[] {
new Foo {
FooId = 1, FooName = "Fake Foo 1"
},
new Foo {
FooId = 2, FooName = "Fake Foo 2"
},
new Foo {
FooId = 3, FooName = "Fake Foo 3"
},
new Foo {
FooId = 4, FooName = "Fake Foo 4"
}
}.AsQueryable());
mock.Setup(m =>
m.GetSingle(
It.Is <int>(i =>
i == 1 || i == 2 || i == 3 || i == 4
)
)
).Returns <int>(r => new Foo {
FooId = r,
FooName = string.Format("Fake Foo {0}", r)
});
fooRepo = mock.Object;
}
public FooService(IConfiguration configuration, IMapper <Foo> mapper, IFooRepository repository)
{
Id = Guid.NewGuid();
Configuration = configuration;
Mapper = mapper;
Name = Guid.NewGuid().ToString("N");
Repository = repository;
}
public FooService(ISettingsProvider settings, IMapper <Foo> mapper, IFooRepository repository)
{
Id = Guid.NewGuid();
Settings = settings;
Mapper = mapper;
Name = Guid.NewGuid().ToString("N");
Repository = repository;
}
/// <summary>
/// Initializes a new instance of the <see cref="FooService" /> class.
/// </summary>
/// <param name="mapper">The mapper.</param>
/// <param name="logHelperFactory">The log helper factory.</param>
/// <param name="fooRepository">The Foo repository.</param>
public FooService(IMapper mapper,
IFooRepository fooRepository)
{
this.Mapper = mapper;
this.FooRepository = fooRepository;
}
/// <summary>
/// Initializes a new instance of the <see cref="CachedFooRepository"/> class.
/// </summary>
/// <param name="cacheDecoratorSettingsProvider">The cacheDecoratorSettingsProvider.</param>
/// <param name="cacheProviderResolver">The cacheProviderResolver</param>
/// <param name="fooRepository">The fooRepository</param>
public CachedFooRepository(ICacheDecoratorSettingsProvider cacheDecoratorSettingsProvider,
ICacheProviderResolver cacheProviderResolver,
IFooRepository fooRepository)
: base(cacheDecoratorSettingsProvider, cacheProviderResolver)
{
this.SetCacheProvider
(
cacheType: CacheTypeEnum.Memory,
declaration: nameof(IFooRepository),
implement: nameof(CachedFooRepository)
);
this.FooRepository = fooRepository;
}
public void Initialize()
{
//Mock repository creation
Mock<IFooRepository> mock = new Mock<IFooRepository>();
mock.Setup(m => m.GetAll()).Returns(new[] {
new Foo { FooId = 1, FooName = "Fake Foo 1" },
new Foo { FooId = 2, FooName = "Fake Foo 2" },
new Foo { FooId = 3, FooName = "Fake Foo 3" },
new Foo { FooId = 4, FooName = "Fake Foo 4" }
}.AsQueryable());
mock.Setup(m =>
m.GetSingle(
It.Is<int>(i =>
i == 1 || i == 2 || i == 3 || i == 4
)
)
).Returns<int>(r => new Foo {
FooId = r,
FooName = string.Format("Fake Foo {0}", r)
});
fooRepo = mock.Object;
}
public FoosController(IFooRepository fooRepository)
{
this._fooRepository = fooRepository;
}
public LayoutInitializer(IFooRepository fooRepository, IBarRepository barRepository)
{
_fooRepository = fooRepository;
_barRepository = barRepository;
}
// コンストラクタで依存を注入できるようにする
public UserApplicationService(IUserRepository userRepository, IFooRepository fooRepository)
{
this.userRepository = userRepository;
this.fooRepository = fooRepository;
}
public FooService(IFooRepository fooRepository)
{
this.fooRepository = fooRepository;
}
public Consumer(IFooRepository fooRepository, IBarRepository barRepository)
{
this.fooRepository = fooRepository;
this.barRepository = barRepository;
}
public GetFooByIdUseCase(IFooRepository fooRepository, ICoreLogger coreLogger) : base(fooRepository, coreLogger)
{
}
public CreateFooCommandHandler(IFooRepository fooRepository)
{
_fooRepository = fooRepository;
}
public FooWindsorInstaller(IFooRepository fooEntityRepository)
{
this.fooEntityRepository = fooEntityRepository;
}
public Processor(IFooRepository fooRepository)
{
_fooRepository = fooRepository;
}
public ApiFooController(IFooRepository fooRepo, IFooFactory fooFactory)
{
_fooRepo = fooRepo;
_fooFactory = fooFactory;
}
public ProductsController(IFooRepository fooRepository)
{
_fooRepository = fooRepository;
}
public FooController(IFooRepository fooRepo)
{
_fooRepo = fooRepo;
}
public FooManager(IFooRepository fooRepository)
{
this.fooRepository = fooRepository;
this.date = DateTime.Now;
}
public FooController(IFooRepository fooRepo)
{
_fooRepo = fooRepo;
}
public UserApplicationService()
{
this.userRepository = ServiceLocator.Resolve <IUserRepository>();
// ServiceLocator経由で取得している
this.fooRepository = ServiceLocator.Resolve <IFooRepository>();
}
public FooService(IFooRepository fooEntityRepository)
{
this.fooEntityRepository = fooEntityRepository;
}
public FooController(IFooRepository repository, ILogger <Foo> logger) : base(repository, logger)
{
}
public CreateFooUseCase(IFooRepository fooRepository, IFooValidator fooValidator, ICoreLogger coreLogger) : base(fooRepository, fooValidator, coreLogger)
{
}
public FooService(IFooRepository repository)
{
Contract.Requires<ArgumentNullException>(repository != null);
_repository = repository;
}
public UserApplicationService()
{
this.userRepository = ServiceLocator.Resolve <IUserRepository>();
// ServiceLocator를 통해 필요한 인스턴스를 받음
this.fooRepository = ServiceLocator.Resolve <IFooRepository>();
}
public UpdateFooValidator(IFooRepository fooRepository)
{
RuleFor(x => x.Id).NotNull().SetValidator(new FooExistsValidator(fooRepository));
}
public FooService(IFooRepository fooRepository, IUserService userService)
{
_fooRepository = fooRepository;
_userService = userService;
}
public FooExistsValidator(IFooRepository fooRepository) : base("Foo does not exist")
{
_fooRepository = fooRepository;
}
public GetAllFoosUseCase(IFooRepository fooRepository, ICoreLogger coreLogger) : base(fooRepository, coreLogger)
{
}
public FooController(IFooRepository fooRepository)
{
_fooRepository = fooRepository;
}
public DeleteFooUseCase(IFooRepository fooRepository, ICoreLogger coreLogger) : base(fooRepository, coreLogger)
{
}
private static IFooService CreateServiceWithValidRepository(IFooRepository repo)
{
Console.WriteLine("Trying to create an instance of {0} service", typeof(FooService).Name);
return new FooService(repo);
}
public GetFooByNameUseCase(IFooRepository fooRepository, ICoreLogger coreLogger)
{
_fooRepository = fooRepository;
_coreLogger = coreLogger;
}
public ValuesController(IFooRepository fooRepo)
{
this.fooRepo = fooRepo;
}
public FooService(IFooRepository fooRepository)
{
_fooRepository = fooRepository;
}
public FooService(IFooRepository repository)
{
_repository = repository;
}
public FooService(IFooRepository mockFooRepository)
{
_mockFooRepository = mockFooRepository;
}
public CanSetSpecificSetting(IFooRepository repo)
: base(repo)
{
}
