C# IRepositoryFactory.GetRepository方法代码示例

 public EventService(IRepositoryFactory factory)
 {
     _personPersonRepo = factory.GetRepository<Person>();
     _gameRepository = factory.GetRepository<Game>();
     _foodRepository = factory.GetRepository<FoodItem>();
     _invitationRepository = factory.GetRepository<PendingInvitation>();
 }

 public NotificationService(IRepositoryFactory factory)
 {
     _personRepository = factory.GetRepository<Person>();
     _eventRepository = factory.GetRepository<Event>();
     _invitationRepository = factory.GetRepository<PendingInvitation>();
     _emailClient = new SmtpClient();
     _useSendGrid = bool.Parse(ConfigurationManager.AppSettings["MailWithSendGrid"]);
 }

 public EventController(IRepositoryFactory factory,
     IEventService service, IUserService userService, INotificationService notificationService)
 {
     _eventRepository = factory.GetRepository<Event>();
     _personRepository = factory.GetRepository<Person>();
     _eventService = service;
     _userService = userService;
     _notificationService = notificationService;
 }

 public ServiceController(IRepositoryFactory factory, IUserService userService, IEventService eventService)
 {
     _eventRepository = factory.GetRepository<Event>();
     _personRepository = factory.GetRepository<Person>();
     _foodRepository = factory.GetRepository<FoodItem>();
     _gameRepository = factory.GetRepository<Game>();
     _inviteRepository = factory.GetRepository<PendingInvitation>();
     _userService = userService;
     _eventService = eventService;
 }

 public HomeController(IRepositoryFactory factory, IUserService userService, INotificationService notificationService,
     IEventService eventService)
 {
     _personRepository = factory.GetRepository<Person>();
     _eventRepository = factory.GetRepository<Event>();
     _foodRepository = factory.GetRepository<FoodItem>();
     _gameRepository = factory.GetRepository<Game>();
     _userService = userService;
     _notificationService = notificationService;
     _eventService = eventService;
 }

        public RightService(ICacheProvider cacheProvider, IRepositoryFactory repositoryFactory, IRoleService roleService)
        {
            _cacheProvider = cacheProvider;

            _repositoryFactory = repositoryFactory;

            _rightRepository = repositoryFactory.GetRepository<BORight, BORightCollection>();

            _roleService = roleService;

            _userRoleRepository = _repositoryFactory.GetRepository<BOUserRole, BOUserRoleCollection>();

            _roleRepository = _repositoryFactory.GetRepository<BORole, BORoleCollection>();
        }

 public ConfigSetTask(IRepositoryFactory repositoryFactory, IEnvironmentTasks environmentTasks)
 {
     this.cacheController = cacheController;
     this.environmentTasks = environmentTasks;
     Repository = repositoryFactory.GetRepository();
     Repository.SavingChanges += SavingChanges;
 }

        public UserService(IRepositoryFactory repositoryFactory, ICacheProvider cacheProvider)
        {
            _cacheProvider = cacheProvider;

            _repositoryFactory = repositoryFactory;

            _userRepository = repositoryFactory.GetRepository<BOUser, BOUserCollection>();
        }

        public RoleService(ICacheProvider cacheProvider, IRepositoryFactory repositoryFactory)
        {
            _repositoryFactory = repositoryFactory;

            _cacheProvider = cacheProvider;

            _roleRepository = _repositoryFactory.GetRepository<BORole, BORoleCollection>();
        }

        public LocalizationService(ICacheProvider cacheProvider, IRepositoryFactory repositoryFactory)
        {
            _cacheProvider = cacheProvider;

            _repositoryFactory = repositoryFactory;

            _localizationResourceRepository = repositoryFactory.GetRepository<BOLocalizationResource, BOLocalizationResourceCollection>();
        }

        public AccountService(IRepositoryFactory repositoryFactory, ISettingService settingService, IUserService userService)
        {
            _repositoryFactory = repositoryFactory;

            _userRepository = _repositoryFactory.GetRepository<BOUser, BOUserCollection>();

            _settingService = settingService;
            _userService = userService;
        }

        public void SpinUp()
        {
            RepositoryFactory = A.Fake<IRepositoryFactory>();
            PersonRepo = A.Fake<IRepository<Person>>();
            EventRepo = A.Fake<IRepository<Event>>();
            InvitationRepo = A.Fake<IRepository<PendingInvitation>>();
            FoodRepo = A.Fake<IRepository<FoodItem>>();
            GameRepo = A.Fake<IRepository<Game>>();
            UserService = A.Fake<IUserService>();

            A.CallTo(() => RepositoryFactory.GetRepository<Person>()).Returns(PersonRepo);
            A.CallTo(() => RepositoryFactory.GetRepository<Event>()).Returns(EventRepo);
            A.CallTo(() => RepositoryFactory.GetRepository<PendingInvitation>()).Returns(InvitationRepo);
            A.CallTo(() => RepositoryFactory.GetRepository<FoodItem>()).Returns(FoodRepo);
            A.CallTo(() => RepositoryFactory.GetRepository<Game>()).Returns(GameRepo);

            EventService = new EventService(RepositoryFactory);
            NotifyService = new NotificationService(RepositoryFactory);
        }

 public LiveScmEditorController(ITracer tracer,
                                IDeploymentManager deploymentManager,
                                IOperationLock operationLock,
                                IEnvironment environment,
                                IRepository repository,
                                IRepositoryFactory repositoryFactory)
     : base(tracer, environment, environment.RepositoryPath)
 {
     _deploymentManager = deploymentManager;
     _operationLock = operationLock;
     _repository = repository ?? repositoryFactory.GetRepository();
 }

        public async static void Seed(IRepositoryFactory repoFactory)
        {
            var users = repoFactory.GetRepository<User>("AspNetUsers");

            var allUsers = await users.All();
            if (!allUsers.Any())
            {
                var john = new User("[email protected]");
                var userStore = new MongoUserStore<User>(repoFactory);
                var userManager = new ApplicationUserManager(userStore);
                var jimi = new User("[email protected]");

                var johnResult = await userManager.CreateAsync(john, "JohnsPassword");
                var jimiResult = await userManager.CreateAsync(jimi, "JimisPassword");

                await userManager.AddClaimAsync(john.Id, new Claim(ClaimTypes.Name, "[email protected]"));
                await userManager.AddClaimAsync(john.Id, new Claim(ClaimTypes.Role, "Admin"));

                await userManager.AddClaimAsync(jimi.Id, new Claim(ClaimTypes.Name, "[email protected]"));
                await userManager.AddClaimAsync(jimi.Id, new Claim(ClaimTypes.Role, "User"));
            }
        }

        public CultureService(IRepositoryFactory repositoryFactory)
        {
            _repositoryFactory = repositoryFactory;

            _cultureRepository = repositoryFactory.GetRepository<BOCulture, BOCultureCollection>();
        }