C# 实现排序、搜索和；使用Redis分页以获得最佳性能

我有大约10万名员工的大数据。我已经将这些数据存储到一个名为“employess”的Redis密钥中。现在有一个屏幕，我想在其中对一些字段执行搜索&对每一列进行排序并分页

因此，我创建了以下工作正常的代码。但平均需要1.2秒到2秒的时间

我想将其缩短为200毫秒（要求）

有没有人可以指导我如何实现这种性能，或者我在下面的代码中做错了什么

我正在使用C#code&ServiceStack.Redis客户端。如果需要，我可以自由使用任何其他Redis客户端

public class Employee
    {
        public int EmployeeId { get; set; }
        public string LastName { get; set; }
        public string FirstName { get; set; }
        public DateTime DOB { get; set; }
        public char Gender { get; set; }
        public string Street { get; set; }
        public string City { get; set; }
        public string State { get; set; }
        public string Zip { get; set; }
        public string Department { get; set; }
        public string Occupation { get; set; }
        public decimal Salary { get; set; }
    }

//处理排序、搜索、分页和从Redis获取数据的方法

  private GeneralResponse<IEnumerable<Employee>> GetEmp(SearchParam filter, int initialPage, int pageSize, out int totalRecords, out int recordFilterd,
           int sortColumn, string sortDirection)
        {
            var response = new GeneralResponse<IEnumerable<Employee>>();
            totalRecords = 0;
            recordFilterd = 0;

            try
            {
                var data = Enumerable.Empty<Employee>().AsQueryable();
                try
                {
                    using (var redisClient = new RedisClient(Common.redisUrl, Common.redisPort))
                    {


                        var rdata = redisClient.Get<IEnumerable<Employee>>("employess");
                        data = rdata.AsQueryable();
                        ViewBag.source = "redis";
                    }
                }
                catch (Exception e)
                {
                    data = Common.EmployeesList.AsQueryable();
                    ViewBag.source = "Database";
                }


                totalRecords = data.Count();
                //filter 
                if (!string.IsNullOrWhiteSpace(filter.FirstName))
                {
                    data = data.Where(x =>
                        x.FirstName.ToLower().Contains(filter.FirstName.Trim().ToLower())
                    );

                }
                if (!string.IsNullOrWhiteSpace(filter.LastName))
                {
                    data = data.Where(x =>
                        x.LastName.ToLower().Contains(filter.LastName.Trim().ToLower())
                    );
                }
                if (!string.IsNullOrWhiteSpace(filter.Department))
                {
                    data = data.Where(x =>
                        x.Department.ToLower() == filter.Department.Trim().ToLower()
                    );
                }
                if (filter.FromDob != null && filter.FromDob != default(DateTime))
                {
                    data = data.Where(x => x.DOB >= filter.FromDob);
                }
                if (filter.ToDob != null && filter.ToDob != default(DateTime))
                {
                    filter.ToDob = filter.ToDob.AddHours(23).AddMinutes(59);
                    data = data.Where(x => x.DOB <= filter.ToDob);

                }
                recordFilterd = data.Count();

                //sort 
                var ascending = sortDirection == "asc";
                switch (sortColumn)
                {
                    case 0:
                        data = data.OrderBy(p => p.EmployeeId, ascending);
                        break;
                    case 1:
                        data = data.OrderBy(p => p.LastName, ascending);
                        break;
                    case 2:
                        data = data.OrderBy(p => p.FirstName, ascending);
                        break;
                    case 3:
                        data = data.OrderBy(p => p.DOB, ascending);
                        break;
                    case 4:
                        data = data.OrderBy(p => p.Gender, ascending);
                        break;
                    case 5:
                        data = data.OrderBy(p => p.Street, ascending);
                        break;
                    case 6:
                        data = data.OrderBy(p => p.City, ascending);
                        break;
                    case 7:
                        data = data.OrderBy(p => p.State, ascending);
                        break;
                    case 8:
                        data = data.OrderBy(p => p.Zip, ascending);
                        break;
                    case 9:
                        data = data.OrderBy(p => p.Department, ascending);
                        break;
                    case 10:
                        data = data.OrderBy(p => p.Occupation, ascending);
                        break;
                    case 11:
                        data = data.OrderBy(p => p.Occupation, ascending);
                        break;
                    default:
                        data = data.OrderBy(p => p.Salary, ascending);
                        break;
                }

                data = data
                    .Skip(initialPage * pageSize)
                    .Take(pageSize);

                var result = data.ToList();
                response.Data = result;

            }
            catch (Exception e)
            {
                response.Error = true;
                response.Exception = e;
            }
            return response;
        } 

private GeneralResponse GetEmp（SearchParam过滤器、int initialPage、int pageSize、out int totalRecords、out int recordFilterd、，
int sortColumn，string sortDirection）
{
var response=新的GeneralResponse（）；
totalRecords=0；
recordFilterd=0；
尝试
{
var data=Enumerable.Empty（）.AsQueryable（）；
尝试
{
使用（var redisClient=new redisClient（Common.redisUrl，Common.redisPort））
{
var rdata=redisClient.Get（“Employeess”）；
data=rdata.AsQueryable（）；
ViewBag.source=“redis”；
}
}
捕获（例外e）
{
data=Common.EmployeesList.AsQueryable（）；
ViewBag.source=“数据库”；
}
totalRecords=data.Count（）；
//滤器
如果（！string.IsNullOrWhiteSpace（filter.FirstName））
{
数据=数据。其中（x=>
x、 FirstName.ToLower（）.Contains（filter.FirstName.Trim（）.ToLower（））
);
}
如果（！string.IsNullOrWhiteSpace（filter.LastName））
{
数据=数据。其中（x=>
x、 LastName.ToLower（）.Contains（filter.LastName.Trim（）.ToLower（））
);
}
如果（！string.IsNullOrWhiteSpace（filter.Department））
{
数据=数据。其中（x=>
x、 Department.ToLower（）==filter.Department.Trim（）.ToLower（）
);
}
if（filter.FromDob！=null&&filter.FromDob！=default（DateTime））
{
数据=数据，其中（x=>x.DOB>=filter.FromDob）；
}
if（filter.ToDob！=null&&filter.ToDob！=default（DateTime））
{
filter.ToDob=filter.ToDob.AddHours（23）、AddMinutes（59）；
数据=数据，其中（x=>x.DOB p.EmployeeId，升序）；
打破
案例1：
data=data.OrderBy（p=>p.LastName，升序）；
打破
案例2：
data=data.OrderBy（p=>p.FirstName，升序）；
打破
案例3：
data=data.OrderBy（p=>p.DOB，升序）；
打破
案例4：
data=data.OrderBy（p=>p.Gender，升序）；
打破
案例5：
data=data.OrderBy（p=>p.Street，升序）；
打破
案例6：
data=data.OrderBy（p=>p.City，升序）；
打破
案例7：
data=data.OrderBy（p=>p.State，升序）；
打破
案例8：
data=data.OrderBy（p=>p.Zip，升序）；
打破
案例9：
data=data.OrderBy（p=>p.Department，升序）；
打破
案例10：
data=data.OrderBy（p=>p.职业，升序）；
打破
案例11：
data=data.OrderBy（p=>p.职业，升序）；
打破
违约：
data=data.OrderBy（p=>p.Salary，升序）；
打破
}
数据=数据
.跳过（初始页面*页面大小）
。取（页面大小）；
var result=data.ToList（）；
响应。数据=结果；
}
捕获（例外e）
{
response.Error=true；
响应异常=e；
}
返回响应；
} 

任何帮助或指导都将不胜感激。下面是我想要达到速度的参考屏幕

---

经过深入研究，我最终发现Redis不是执行这些操作的好选择。我们可以选择AWS CloudSearch，它具有完整的排序、搜索和分页功能

经过深入研究，我最终发现Redis不是执行这些操作的好选择。我们可以选择AWS CloudSearch，它具有完整的排序、搜索和分页功能

正如上面的评论和您的回答中提到的，redis可能不是解决此问题的最佳选择，AWS CloudSearch可能是解决方案

在解决类似问题时，我发现最大的瓶颈是使用“query.Where（x=>x.String.Contains（filterText））`

在文本搜索列上添加全文索引（第一个/最后一个n