C# IUnitOfWork.Repository方法代码示例

        public PhotoSaveService(IUnitOfWork uof)
        {

            photosDb = uof.Repository<Photo>();
            usersDb = uof.Repository<User>();
            accountsDb = uof.Repository<Account>();
        }

 public NotesManagerService(IUnitOfWork unitOfWork)
 {
     _unitOfWork = unitOfWork;
     _noteRepo = _unitOfWork.Repository<Note>();
     _fillerFormRepo = _unitOfWork.Repository<FillerForm>();
     _questionAnswerMapRepo = _unitOfWork.Repository<QuestionAnswerMapping>();
     _acpAnswerRepo = _unitOfWork.Repository<AcpAnswer>();
     _acpQuesListItemRepo = _unitOfWork.Repository<AcpQuestionListItem>();
 }

        public PhotosController()
        {
            uof = DependencyResolver.Current.GetService<IUnitOfWork>();
            accountsDb = uof.Repository<Account>();
            rolesDb = uof.Repository<Role>();
            usersDb = uof.Repository<User>();
            photosDb = uof.Repository<Photo>();

            photoSaveService = DependencyResolver.Current.GetService<PhotoSaveService>();
        }

        public NotesService(IUnitOfWork unitOfWork, IQueries queries)
        {
            if (unitOfWork == null)
            {
                throw new ArgumentNullException("unitOfWork");
            }

            if (queries == null)
            {
                throw new ArgumentNullException("queries");
            }

            _queries = queries;

            _unitOfWork = unitOfWork;
            _notesRepository = _unitOfWork.Repository<Note>();
        }

 public StudentManagerService(IUnitOfWork unitOfWork)
 {
     _unitOfWork = unitOfWork;
     _studentRepo = _unitOfWork.Repository<Student>();
     _mappingRepo = _unitOfWork.Repository<FriendStudentMapping>();
 }

 public HtmlPageService(IUnitOfWork unitOfWork)
 {
     _unitOfWork = unitOfWork;
     _pagerepos = _unitOfWork.Repository<HtmlPage>();
 }

 public TransactionController(IUnitOfWork unitOfWork)
 {
     _unitOfWork = unitOfWork;
     transactionRepository = _unitOfWork.Repository<Transaction>();
 }

 public void Load(IUnitOfWork uow)
 {
     TBL_COACH coach;
     switch (this.Role)
     {
         case SandlerRoles.Coach:
             coach = uow.Repository<TBL_COACH>().GetAll().Where(r => r.UserID == this.UserId).SingleOrDefault();
             this.CoachID = coach.ID;
             this.RegionID = uow.Repository<TBL_REGION>().GetById(coach.RegionID).ID;
             break;
         case SandlerRoles.FranchiseeOwner:
         case SandlerRoles.FranchiseeUser:
         case SandlerRoles.Client:
             this.FranchiseeID = uow.Repository<TBL_FRANCHISEE_USERS>().GetAll().Where(r => r.UserID == this.UserId).SingleOrDefault().FranchiseeID;
             TBL_FRANCHISEE franchisee = uow.Repository<TBL_FRANCHISEE>().GetAll().Where(r => r.ID == this.FranchiseeID).SingleOrDefault();
             this.FranchiseeName = franchisee.Name;
             coach = uow.Repository<TBL_COACH>().GetById(franchisee.CoachID);
             this.CoachID = coach.ID;
             this.RegionID = uow.Repository<TBL_REGION>().GetById(coach.RegionID).ID;
             break;
         case SandlerRoles.SiteAdmin:
         case SandlerRoles.HomeOfficeAdmin:
             break;
         default:
             break;
     }
 }

 public HomeController(IUnitOfWork unitOfWork)
 {
     _unitOfWork = unitOfWork;
     _shopRepository = _unitOfWork.Repository<Shop>();
 }

 public bool TryParse(MovieReview review, ReviewModel reviewModel, IUnitOfWork _unitOfWork, ModelStateDictionary modelState)
 {
     bool isValid = true;
     var movie = _unitOfWork.Repository<Movie>().Query()
         .Filter(m => m.Title.ToLower() == reviewModel.Movie.ToLower())
         .FirstOrDefault();
     if (movie == null)
     {
         modelState.AddModelError("Movie", "Not a valid Movie");
         isValid = false;
     }
     var reviewer = _unitOfWork.Repository<Reviewer>().Query()
         .Filter(r => r.Name.ToLower() == reviewModel.Reviewer.ToLower())
         .FirstOrDefault();
     if (reviewer == null)
     {
         modelState.AddModelError("Reviewer", "Not a valid Reviewer");
         isValid = false;
     }
     review.Movie = movie;
     review.Reviewer = reviewer;
     review.ReviewedDate = reviewModel.ReviewedDate;
     review.TagLine = reviewModel.TagLine;
     review.Rating = reviewModel.Rating;
     review.Review = reviewModel.Review;
     return isValid;
 }

        private ICollection<MovieArtist> ParseArtists(Movie movie, MovieModel movieModel, IUnitOfWork _unitOfWork)
        {
            MovieArtist movieArtist;
            ArtistRole[] roles = { ArtistRole.Hero, ArtistRole.Heroin, ArtistRole.Director, ArtistRole.Producer, ArtistRole.MusicDirector };
            string artistName;

            if (movie.Artists == null)
            {
                movie.Artists = new List<MovieArtist>();
            }

            foreach (var role in roles)
            {
                artistName = movieModel.GetNameByRole(role);

                if (!string.IsNullOrEmpty(artistName))
                {
                    var artist = _unitOfWork.Repository<Artist>().Query().Filter(a => string.Equals(artistName, a.Name)).FirstOrDefault();

                    if (artist == null)
                    {
                        artist = new Artist() { Name = artistName, PrimaryRole = role, State = ObjectState.Added };
                    }

                    if (string.IsNullOrEmpty(movie.GetArtistName(role)))
                    {
                        movieArtist = new MovieArtist() { Artist = artist, Movie = movie, Role = role, State = ObjectState.Added };
                        movie.Artists.Add(movieArtist);
                    }
                    else if (movie.GetArtistName(role) != artistName)
                    {
                        movieArtist = movie.Artists.Where(ma => ma.Role == role).FirstOrDefault();
                        movieArtist.Artist = artist;
                        movieArtist.State = ObjectState.Modified;
                    }
                }
                else if (!string.IsNullOrEmpty(movie.GetArtistName(role)))
                {
                    movieArtist = movie.Artists.Where(ma => ma.Role == role).FirstOrDefault();
                    movieArtist.State = ObjectState.Deleted;
                }
            }
            return movie.Artists;
        }

 public MemberService(IUnitOfWork unitOfWork)
 {
     this.unitOfWork = unitOfWork;
     this.repository = unitOfWork.Repository<Member>();
 }

 public CategoryService(IUnitOfWorkFactory factory)
 {
     _unitOfWork = factory.Create();
    _repository = _unitOfWork.Repository<Category>();
 }

 public SubTaskService(IUnitOfWorkFactory factory)
 {
     _unitOfWork = factory.Create();
     _taskRepository = _unitOfWork.Repository<Task>();
     _repository = _unitOfWork.Repository<SubTask>();
 }

 public WorkoutsController(IUnitOfWork uow)
 {
     unitOfWork = uow;
     repository = unitOfWork.Repository<long, Workouts>();
 }