C# ISession.Query方法代码示例

 public static Dictionary<string, Tag> GetTags(ISession session, string[] tagNames)
 {
     if (tagNames.Length < 20) {
         var direct = session.Query<Tag>().Where(t => tagNames.Contains(t.Name)).ToArray();
         return direct.Union(direct.Where(t => t.AliasedTo != null).Select(t => t.AliasedTo)).ToDictionary(t => t.Name, new CaseInsensitiveStringComparer());
     } else {
         return session.Query<Tag>().ToDictionary(t => t.Name);
     }
 }

        public PlaceOrderModel(ISession s)
        {
            OrderItemModels = new List<OrderItemModel>();

            var customerReports = s.Query<CustomerReport>().ToList<CustomerReport>();

            var productReports = s.Query<ProductStockReport>()
                .Select(c => new { AggregateRootId = c.AggregateRootId, Name = c.Name + " " + c.Code })
                .ToList();

            Customers = new SelectList(customerReports, "AggregateRootId", "Name");

            Products = new SelectList(productReports, "AggregateRootId", "Name");
        }

        protected override int TestAndAssert(Expression<Func<MyBO, bool>> condition, ISession session, IEnumerable<int> expectedIds)
        {
            IQueryable<int?> result = session.Query<MyBO>().Where(condition).Select(bo => (int?)bo.BO1.Id);

            var forceDBRun = result.ToList();

            IEnumerable<int> resultNullTo0 = forceDBRun.Select(i => i ?? 0);

            var expectedBO1Ids = session.Query<MyBO>().Where(bo => expectedIds.Contains(bo.Id)).Select(bo => bo.BO1 == null ? 0 : bo.BO1.Id).ToList();
            AreEqual(expectedBO1Ids, resultNullTo0.ToArray());

            // Unused result.
            return -1;
        }

        public List<RiskAssessmentReviewTask> Execute(Guid employeeId, ISession session)
        {
            try
            {
                //Log.Debug("GetOverdueRiskAssessmentReviewTasks - Execute()");
                var queryableRiskAssessmentsReviews = session.Query<RiskAssessment>()
                    .Where(
                        x =>
                            x.Deleted == false &&
                            (x.Status == RiskAssessmentStatus.Draft || x.Status == RiskAssessmentStatus.Live))
                    .SelectMany(x => x.Reviews)
                    .Where(ReviewTaskIsAssignedToEmployeeOrEmployeeIsTheRiskAssessor(employeeId))
                    .Where(ReviewTasksAreOverdue());

                var riskAssessmentReviewTasks = new List<RiskAssessmentReviewTask>();

                queryableRiskAssessmentsReviews.ForEach(
                    task =>
                    {
                        if (DoesTaskNeedToBeNotified(task, employeeId))
                            riskAssessmentReviewTasks.Add(task.RiskAssessmentReviewTask);
                    });

                return riskAssessmentReviewTasks;
            }
            catch (Exception ex)
            {
                Log.Debug("Exception - GetOverdueRiskAssessmentReviewTasks - Execute()" + ex.Message);
                throw;
            }
        }

 private static List<Group> GetGroups(ISession session)
 {
     return session.Query<Group>()
         .Cacheable()
         .CacheMode(CacheMode.Normal)
         .ToList();
 }

        public List<ActionTask> Execute(Guid employeeId, ISession session)
        {
            try
            {
                //Log.Debug("GetOverdueResponsibilitiesTasksForEmployeeQuery - Execute()" );

                var overdueActionTasks = session
                    .Query<BusinessSafe.Domain.Entities.Action>()
                    .Where(x => x.Deleted == false)
                    .SelectMany(x => x.ActionTasks)
                    .Where(TasksAreAssignedToTheEmployee(employeeId))
                    .Where(TasksAreOverdue());

                var overdueActionTasksTemp = new List<ActionTask>();

                overdueActionTasks.ForEach(
                    task =>
                    {
                        if (DoesTaskNeedToBeNotified(task, employeeId))
                            overdueActionTasksTemp.Add(task);

                    });

                return overdueActionTasksTemp;
            }
            catch (Exception ex)
            {
                Log.Debug("Exception - GetOverdueResponsibilitiesTasksForEmployeeQuery - Execute()" + ex.Message);
                throw;
            }
        }

     public List<HazardousSubstanceRiskAssessmentFurtherControlMeasureTask>  Execute(Guid employeeId, ISession session)
        {
            try
            {
                //Log.Debug("GetOverdueHazardousSubstanceRiskAssessmentFurtherControlMeasureTasksForEmployeeQuery - Execute()");
                var queryTasksWhereEmployeeIsRiskAssessor = session.Query<HazardousSubstanceRiskAssessment>()
                    .Where(x => x.Deleted == false // dont return tasks for deleted risk assessments
                                && (x.Status == RiskAssessmentStatus.Draft || x.Status == RiskAssessmentStatus.Live))
                    .SelectMany(x => x.FurtherControlMeasureTasks)
                    .Where(x => x.Deleted == false)
                    .Where(TaskIsAssignedToEmployeeOrEmployeeIsTheRiskAssessor(employeeId))
                    .Where(TasksAreOverdue());

                var hazardousSubstanceRiskAssessmentFurtherControlMeasureTasks =
                    new List<HazardousSubstanceRiskAssessmentFurtherControlMeasureTask>();

                queryTasksWhereEmployeeIsRiskAssessor.ForEach(
                    task =>
                    {
                        if (DoesTaskNeedToBeNotified(task, employeeId))
                            hazardousSubstanceRiskAssessmentFurtherControlMeasureTasks.Add(task);
                    });

                return hazardousSubstanceRiskAssessmentFurtherControlMeasureTasks.ToList();
            }
            catch (Exception ex)
            {
                Log.Debug("Exception - GetOverdueHazardousSubstanceRiskAssessmentFurtherControlMeasureTasksForEmployeeQuery - Execute()" + ex.Message);
                throw;
            }
        }

        public List<ActionTask> Execute(Guid employeeId, ISession session)
        {
            try
            {
                //Log.Debug(" GetDueActionTasksForEmployeeQuery - Execute()");

                var overdueActionTasks = session.Query<Domain.Entities.Action>().Where(x => x.Deleted == false)
                    .SelectMany(x => x.ActionTasks)
                    .Where(EmployeeIsTheAssignee(employeeId))
                    .Where(TasksAreDue());

                var actionTasks = new List<ActionTask>();
  
                overdueActionTasks.ForEach(
                    task =>
                    {
                        if (IsTaskDue(task))
                         actionTasks.Add(task);   
                    }); 
                                     
                 return actionTasks;
            }
            catch (Exception ex)
            {
                Log.Debug("Exception - GetDueActionTasksForEmployeeQuery - Execute()" + ex.Message);
                throw;
            }
        }

        public List<RiskAssessmentReviewTask> Execute(Guid employeeId, ISession session)
        {
            try
            {
                //Log.Debug("GetDueRiskAssessmentReviewTasksForEmployeeQuery - Execute()");
                var queryableRiskAssessmentsReviews = session.Query<RiskAssessment>()
                    .Where(
                        x =>
                            x.Deleted == false &&
                            (x.Status == RiskAssessmentStatus.Draft || x.Status == RiskAssessmentStatus.Live))
                    .SelectMany(x => x.Reviews)
                    .Where(ReviewTasksAreDue())
                    .Where(ReviewTaskEmployeeIsAssigneeeOrRiskAssessor(employeeId));

                var riskAssessmentReviewTasks = new List<RiskAssessmentReviewTask>();

                queryableRiskAssessmentsReviews.ForEach(
                    review =>
                    {
                        if (IsTaskDue(review))
                            riskAssessmentReviewTasks.Add(review.RiskAssessmentReviewTask);
                    });

                return riskAssessmentReviewTasks;
            }
            catch (Exception ex)
            {
                Log.Debug("Exception - GetDueRiskAssessmentReviewTasksForEmployeeQuery - Execute()" + ex.Message);
                throw;
            }
        }

        public List<ResponsibilityTask> Execute(Guid employeeId, ISession session)
        {
            try
            {
                //Log.Debug("GetDueResponsibilityTasksForEmployeeQuery - Execute()");
                var queryTasksWhereAssignedToIsEmployee = session.Query<Responsibility>()
                    .Where(r => r.Deleted == false)
                    .SelectMany(r => r.ResponsibilityTasks)
                    .Where(TasksAreDue())
                    .Where(EmployeeIsTheAssignee(employeeId));

                var responsibilityTasks = new List<ResponsibilityTask>();

                queryTasksWhereAssignedToIsEmployee.ForEach(
                    task =>
                    {
                        if (IsTaskDue(task))
                            responsibilityTasks.Add(task);
                    });

                return responsibilityTasks;
            }
            catch (Exception ex)
            {
                Log.Debug("Exception - GetDueResponsibilityTasksForEmployeeQuery - Execute()" + ex.Message);
                throw;
            }
        }

        private object[] GetWidgetListModel(Guid dashboardId, ISession session)
        {
            var allWidgets = session.Query<Widget>()
                .Where(w => w.Dashboard.Id == dashboardId)
                .ToArray();

            var list = new List<object>();

            foreach (var widget in allWidgets)
            {
                var typeDisplayName = defs.ContainsKey(widget.TypeAlias)
                    ? defs[widget.TypeAlias].DisplayName
                    : string.Format("Unknown ({0})", widget.TypeAlias);

                var model = new
                {
                    id = widget.Id,
                    type = widget.TypeAlias,
                    displayName = widget.DisplayName,
                    sortOrder = widget.SortOrder,
                    typeDisplayName
                };

                list.Add(model);
            }

            return list.ToArray();
        }

        private void ValidarNome(Usuario usuario, ISession session)
        {
            var qdtUsuariosComMesmoNome = session.Query<Visao>()
                .Count(i => i.Nome.Equals(usuario.UserName) && (i.Id != usuario.Id));

            if (qdtUsuariosComMesmoNome > 0)
                throw new BLLException("Esse username já está sendo usado por outro usuário.");
        }

 public static IEnumerable<ColumnItemResult> RetrievingColumnsByTableId(int tableId, ISession session)
 {
     return session.Query<ColumnEntity>()
         .Where(x => x.ParentTable.Id == tableId)
         .Select(x => new ColumnItemResult { Id = x.Id, ColumnName = x.Name })
         .OrderBy(x => x.ColumnName)
         .ToList();
 }

 public static TableInformationResult RetrieveTableInformationByTableId(int tableId, ISession session)
 {
     return
         session.Query<TableEntity>()
             .Where(x => x.Id == tableId)
             .Select(x => new TableInformationResult { Id = x.Id, DatabaseName = x.DatabaseName, Description = x.Description, SchemaName = x.SchemaName, TableName = x.Name })
             .First();
 }

        private IList<NHAlbum> NHGetTopSellingAlbums(int count)
        {
            _session = MvcApplication.SessionFactory.GetCurrentSession();

            var _query = from a in _session.Query<NHAlbum>()
                         orderby a.OrderDetails.Count
                         select a;
            return _query.Take(5).ToList();
        }