C# 两个数据库的ASP.NET MVC LINQ性能问题

我在ASP.NET MVC应用程序中工作，有两个不同的连接（数据库）。它就像一个应用程序，用户在其中进行一些小的测试。在一个页面上，我必须向用户显示所有已完成的考试/活动的详细信息：时间、结果以及有关活动/考试的所有详细信息。红色数据库中只有关于结果、时间、用户和activityid的信息，因此您可以在另一个（蓝色）数据库中获取该跟踪的活动。每项活动最多可进行5次

我尝试了几个不同的查询，但是性能非常非常慢。你知道我如何解决这个问题，而用户不必在页面上等待10秒吗

谢谢大家!

编辑：

跟踪表（db1，表1）现在有1732982条记录，而且它一直在增长，因为用户可以在他们愿意的时候进行检查。目前共有1832项活动，来自110个课程

下面是详细的数据库图片（这是我得到的，所以我必须使用它，但如果需要，我可以更改id/pk/fk，或者更改我需要的任何内容，但它必须保留在两个不同的数据库中）：

下面是用于为一个用户获取结果的代码。用户ID像函数中的参数一样发送，并在代码中使用

        IList<TrackingCustomModel> result = new List<TrackingCustomModel>();
        using (DATA.examContent.Model ctc = new DATA.examContent.Model()) //first database (activities, lessons)
        {
            using (Model ctx = new Model()) //this is second database (tracking)
            {
                // Get all Activities
                IList<Activity> ac = ctc.Activity.Include("Lesson").ToList();
                char[] trimChars = { '0' };
                IEnumerable<TrackingCustomModel> q;
                    q = from a in ac
                        select new TrackingCustomModel
                        {
                            ActivityId = a.Id,
                            LessonCode = a.Lesson.Code.TrimStart(trimChars),
                            ActivityCode = a.Code.TrimStart(trimChars),
                            ActivityHead = a.Head.Trim()
                        };
                IList<TrackingCustomModel> add = q.ToList<TrackingCustomModel>();
                // Get all Trackings for userId
                IList<Tracking> tr = ctx.Tracking.Where(t => t.UserId == userId).ToList();

                // Join Activites with Tracking of User, and Calculate Scores
                var s = from a in add
                        join t in tr on a.ActivityId equals t.ActivityId
                        orderby t.Timestamp descending
                        select new TrackingCustomModel
                        {
                            ActivityId = a.ActivityId,
                            LessonCode = a.LessonCode,
                            ActivityCode = a.ActivityCode,
                            ActivityHead = a.ActivityHead,
                            Timestamp = DefaultHelper.AdjustDateToLocalTimezone(t.Timestamp),
                            ActivityHits = t.ActivityHits,
                            ActivityMistakes = t.ActivityMistakes,
                            ActivityScore = (t.ActivityHits + t.ActivityMistakes) > 0 ? (String.Format("{0:0%}", (Decimal.Divide(t.ActivityHits, (t.ActivityHits + t.ActivityMistakes))))).ToString() : null
                        };


                // Group the results by Activity and calculate the Activity average

                var group = from t in s
                            group t by t.ActivityId into g
                            select g;
                foreach (IGrouping<Guid, TrackingCustomModel> g in group)
                {
                    TrackingCustomModel thc = (from t in g
                                               where t.ActivityId == g.Key
                                               select t).FirstOrDefault();

                    IList<TrackingCustomModel> multipleTry = (from d in s
                                                              where d.ActivityId == g.Key
                                                              select d).ToList();
                    if (multipleTry.Count > 1)
                    {
                        thc.ActivityDone = multipleTry.Count.ToString();
                        Decimal scoreAsDecimal;
                        Decimal averageScore = 0;
                        foreach (TrackingCustomModel t in multipleTry)
                        {
                            if (t.ActivityHits != 0)
                            {
                                scoreAsDecimal = (Decimal.Divide(t.ActivityHits, (t.ActivityHits + t.ActivityMistakes)));
                                averageScore += scoreAsDecimal;
                            }
                        }
                        averageScore /= multipleTry.Count;
                        if (averageScore != 0)
                        {
                            thc.AverageScore = String.Format("{0:0%}", averageScore).ToString();
                        }
                        else
                        {
                            thc.AverageScore = "";
                        }
                    }
                    else
                    {
                        thc.ActivityDone = "";
                    }
                    result.Add(thc);
                }
            }
        }
        return result;

IList结果=新列表（）；
使用（DATA.examContent.Model ctc=new DATA.examContent.Model（））//第一个数据库（活动、课程）
{
使用（Model ctx=new Model（））//这是第二个数据库（跟踪）
{
//获取所有活动
IList ac=ctc.Activity.Include（“课程”）.ToList（）；
char[]trimChars={0'}；
可数q；
q=交流中的a
选择新的TrackingCustomModel
{
ActivityId=a.Id，
LessonCode=a.Lesson.Code.TrimStart（trimChars），
ActivityCode=a.Code.TrimStart（trimChars），
ActivityHead=a.Head.Trim（）
};
IList add=q.ToList（）；
//获取userId的所有跟踪
IList tr=ctx.Tracking.Where（t=>t.UserId==UserId.ToList（）；
//加入跟踪用户的活动，并计算分数
var s=来自添加项中的
在tr中加入t。ActivityId等于t.ActivityId
orderby t.时间戳递减
选择新的TrackingCustomModel
{
ActivityId=a.ActivityId，
LessonCode=a.LessonCode，
ActivityCode=a.ActivityCode，
ActivityHead=a.ActivityHead，
Timestamp=DefaultHelper.AdjustDateToLocalTimezone（t.Timestamp），
ActivityHits=t.ActivityHits，
ActivityMistakes=t.ActivityMistakes，
ActivityScore=（t.ActivityHits+t.ActivityMistakes）>0？（String.Format（“{0:0%}）”，（Decimal.Divide（t.ActivityHits，（t.ActivityHits+t.ActivityMistakesщщ））.ToString（）：null
};
//将结果按活动分组，并计算活动平均值
var组=从t到s
按t.ActivityId将t分组为g
选择g；
foreach（将g分组）
{
TrackingCustomModel thc=（从t到g
其中t.ActivityId==g.Key
选择t）.FirstOrDefault（）；
IList倍率=（从d到s
其中d.ActivityId==g.Key
选择d）.ToList（）；
如果（multiplery.Count>1）
{
thc.ActivityDone=multiplery.Count.ToString（）；
十进制分数为十进制；
十进制平均分数=0；
foreach（在倍增中跟踪CustomModel t）
{
如果（t.ActivityHits！=0）
{
scoreAsDecimal=（Decimal.Divide（t.ActivityHits，（t.ActivityHits+t.ActivityMistakes））；
averageScore+=分数为十进制；
}
}
averageScore/=倍数法计数；
如果（平均分数！=0）
{
thc.AverageScore=String.Format（“{0:0%}”，AverageScore）.ToString（）；
}
其他的
{
thc.AverageScore=“”；
}
}
其他的
{
thc.ActivityDone=“”；
}
结果：添加（thc）；
}
}
}
返回结果；

从数据库1获取所有相关活动的列表

从数据库2获取所有活动信息+课程信息

找出什么是慢的，1还是2

慢速活动列表查询（步骤1） 确保索引where子句。例如，用户ID，可能包括日期时间

慢速活动信息/课程信息查询（步骤2） 确保Activity.ActiviyID已编制索引，因为这是您应该在第二次查询中搜索的内容

应通过Lesson.LessonID搜索课程信息，并对其进行索引

如果使用EF，请执行以下操作：

var res = Activities        
    .Include(x => x.Lesson) 
    .Where(x => activityIds.Contains(x.AcitivityID))
    .ToList()

从活动到带来

 IList<Activity> ac = ctc.Activity.Include("Lesson").ToList();