C# IEmployeeService.GetAll方法代码示例

        public EmployeeCostEntryViewModel(
            IMessageBroker messageBroker, 
            IEmployeeCostService costService,
            IEmployeeService employeeService,
            SaveEmployeeCostCommand saveCostCommand,
            CancelCommand cancelCommand, ShowEmployeeCostCommand showListCommand
            )
        {
            this.messageBroker = messageBroker;
            this.costService = costService;
            this.employeeService = employeeService;
            ActualSaveCommand = saveCostCommand;

            CancelCommand = cancelCommand;
            ShowCostListCommand = showListCommand;
            InitializeCommands();
            NavigationCommands = new List<CommandBase>{SaveCommand,CancelCommand};
            CancelCommand.Action = broker => showListCommand.Execute(null);

            PropertiesToValidate = new List<string>()
            {
                "Date",
                "Total",
                "Details"
            };

            Employees = new ObservableCollection<Employee>(employeeService.GetAll());

            SubscribeMessages();
        }

        public EmployeesVM(
            IRibbonService ribbonService,
            IEmployeeService employeeService,
            IRegionManager regionManager
            )
        {
            this.ribbonService = ribbonService;
            this.newCommand = new DelegateCommand<bool?>(this.New, this.CanNew);
            this.deleteCommand = new DelegateCommand<bool?>(this.Delete, this.CanDelete);
            this.editCommand = new DelegateCommand<bool?>(this.Edit, this.CanEdit);

            this.ViewRequest = new InteractionRequest<INotification>();

            employees = new ObservableCollection<BasicEmployeeVM>();
            RegionManager = regionManager;
            Mapper.CreateMap<Employee, BasicEmployeeVM>();
            Mapper.CreateMap<WorkCode, BasicWorkCodeVM>();
            Mapper.CreateMap<WorkHour, BasicWorkHourVM>();

            Mapper.CreateMap<BasicWorkCodeVM, WorkCode>();
            Mapper.CreateMap<BasicEmployeeVM, Employee>();

            Mapper.CreateMap<ICollection<WorkHour>, ICollection<BasicWorkHourVM>>();
            Mapper.CreateMap<ICollection<WorkCode>, ICollection<BasicWorkCodeVM>>();
            Mapper.CreateMap<ICollection<Employee>, ICollection<BasicEmployeeVM>>();
            Mapper.CreateMap<ICollection<BasicWorkHourVM>, ICollection<WorkHour>>();

            foreach (Employee data in employeeService.GetAll())
            {
                employees.Add(Mapper.Map<Employee, BasicEmployeeVM>(data));
            }

            EmployeesCV = new ListCollectionView(Employees);
            EmployeesCV.CurrentChanged += EmployeesCV_CurrentChanged;
            this.employeeService = employeeService;
        }

        private void Setup()
        {
            Console.WriteLine("Import operation starting");

            var sessionFactory = GetSessionFactory(_connectionString);
            var session = sessionFactory.OpenSession();

            CurrentSessionContext.Bind(session);
            
            ObjectFactory.Container.Configure(x =>
                                                  {
                                                      x.ForSingletonOf<IBusinessSafeSessionFactory>().Use<BusinessSafeSessionFactory>();
                                                      x.For<IBusinessSafeSessionManager>().HybridHttpOrThreadLocalScoped().Use<CurrentContextSessionManager>();                                                      
                                                      x.AddRegistry<ApplicationRegistry>();
                                                      x.For<IBus>().Use<StubBus>();
                                                  });

            _employeeService = ObjectFactory.GetInstance<IEmployeeService>();
            
            
            //populates the existing employee list only once based on client. i.e. The clientId must be same for all the records on excel sheet.
            //so do not need to query the database again & again for the same client.
            if (_existingEmployeesList == null)
            {
                _existingEmployeesList = _employeeService.GetAll(_clientID).ToList();
            }

            session.Flush();
            sessionFactory.GetCurrentSession().Dispose();
            CurrentSessionContext.Unbind(sessionFactory);
        }

        public WorkHourVM(
            IRibbonService ribbonService,
            IWorkCodeService workCodeService,
            IEmployeeService employeeService,
            IWorkHourService workHourService
            )
        {
            this.ribbonService = ribbonService;
            this.saveCommand = new DelegateCommand<bool?>(this.Save, this.CanSave);
            this.deleteCommand = new DelegateCommand<bool?>(this.Delete, this.CanDelete);
            this.workCodeService=workCodeService;
            this.workHourService = workHourService;

            WorkCodes = new ObservableCollection<BasicWorkCodeVM>();
            employees = new ObservableCollection<BasicEmployeeVM>();
            workHours = new ObservableCollection<BasicWorkHourVM>();


            DeletedWorkHours = new List<BasicWorkHourVM>();

          

            Mapper.CreateMap<Employee, BasicEmployeeVM>();
            Mapper.CreateMap<BasicEmployeeVM, Employee>();
            Mapper.CreateMap<ICollection<Employee>, ICollection<BasicEmployeeVM>>();
            Mapper.CreateMap<ICollection<BasicEmployeeVM>, ICollection<Employee>>();
            
            Mapper.CreateMap<WorkCode, BasicWorkCodeVM>();
            Mapper.CreateMap<ICollection<WorkCode>, ICollection<BasicWorkCodeVM>>();
            Mapper.CreateMap<BasicWorkCodeVM, WorkCode>();
            Mapper.CreateMap<ICollection<BasicWorkCodeVM>, ICollection<WorkCode>>();
            
            Mapper.CreateMap<WorkHour, BasicWorkHourVM>();
            Mapper.CreateMap<BasicWorkHourVM, WorkHour>();
            Mapper.CreateMap<ICollection<WorkHour>, ICollection<BasicWorkHourVM>>();
            Mapper.CreateMap<ICollection<BasicWorkHourVM>, ICollection<WorkHour>>();

            foreach (Employee data in employeeService.GetAll())
            {
                employees.Add(Mapper.Map<Employee, BasicEmployeeVM>(data));
            }
            
            foreach (WorkCode data in workCodeService.GetAll())
            {
                WorkCodes.Add(Mapper.Map<WorkCode, BasicWorkCodeVM>(data));
            }

            foreach (WorkHour data in workHourService.GetAll())
            {
                data.ObjectState = ObjectState.Unchanged;
                workHours.Add(Mapper.Map<WorkHour, BasicWorkHourVM>(data));
            }
            WorkHoursCV = new ListCollectionView(WorkHours);
            WorkHoursCV.CurrentChanged += WorkHoursCV_CurrentChanged;
        }