C# LINQ至对象打开高-低-关闭

我希望通过使用语法LINQ query to object从下面的代码示例中获得相同的结果。 请帮帮我，伙计们

public static List<OHLC> OHLC(List<FileRaw> fileRawsList, TimeSpan timeSpan, DateTime beginDate, DateTime endOfLoopDate)
    {

        List<OHLC> ohlcList = new List<OHLC>();

        for (DateTime i = beginDate; i < endOfLoopDate; )
        {
            DateTime iLow = i;
            DateTime iMax = i.Add(timeSpan);
            OHLC ohlcRaw = new OHLC()
                {
                    Open = fileRawsList.Where(p => p.Time >= iLow).Where(p => p.Time <= iMax).Select(p => p.Bid).DefaultIfEmpty().First(),
                    High = fileRawsList.Where(p => p.Time >= iLow).Where(p => p.Time <= iMax).Select(p => p.Bid).DefaultIfEmpty().Max(),
                    Low = fileRawsList.Where(p => p.Time >= iLow).Where(p => p.Time <= iMax).Select(p => p.Bid).DefaultIfEmpty().Min(),
                    Close = fileRawsList.Where(p => p.Time >= iLow).Where(p => p.Time <= iMax).Select(p => p.Bid).DefaultIfEmpty().Last(),
                    Time = fileRawsList.Where(p => p.Time >= iLow).Where(p => p.Time <= iMax).Select(p => p.Time).DefaultIfEmpty(iLow).First()
                };

            i = i.Add(timeSpan);
            ohlcList.Add(ohlcRaw);
        }
        return ohlcList;
    }

---

这将为原始组提供：

 return fileRawList.Where(file => file.Time >= beginDate)
                    .Where(file => file.Time < endofLoopDate)
                    .OrderBy(file => file.Time)
                    .GroupBy(file => file.Time.Ticks / timeSpan.Ticks,
                             (k, g) => new OHLC()
                                  {
                                    Open = g.Select(p => p.Bid).DefaultIfEmpty().First(),
                                    High = g.Select(p => p.Bid).DefaultIfEmpty().Max(),
                                    Low = g.Select(p => p.Bid).DefaultIfEmpty().Min(),
                                    Close = g.Select(p => p.Bid).DefaultIfEmpty().Last(),
                                    Time = g.Select(p => p.Time).DefaultIfEmpty().First()
                                          })
                     .ToList();

返回fileRawList.Where（file=>file.Time>=beginDate）
.Where（file=>file.Timefile.Time）
.GroupBy（file=>file.Time.Ticks/timeSpan.Ticks，
（k，g）=>新的OHLC（）
{
Open=g.Select（p=>p.Bid）.DefaultIfEmpty（）.First（），
High=g.Select（p=>p.Bid）.DefaultIfEmpty（）.Max（），
Low=g.Select（p=>p.Bid）.DefaultIfEmpty（）.Min（），
Close=g.Select（p=>p.Bid）.DefaultIfEmpty（）.Last（），
Time=g.Select（p=>p.Time）.DefaultIfEmpty（）.First（）
})
.ToList（）；

虽然这应提供OHLC的常规流程：

var rawGroups = fileRawList.Where(file => file.Time >= beginDate)
                    .Where(file => file.Time < endofLoopDate)
                    .OrderBy(file => file.Time)
                    .ToLookup(file => (file.Time.Ticks - beginDate.Ticks) / timeSpan.Ticks,
                              file => new {Bid = file.Bid, Time = file.Time})
                    .ToDictionary( g => g.Key, g => new OHLC()
                                  {
                                    Open = g.Select(p => p.Bid).DefaultIfEmpty(0).First(),
                                    High = g.Select(p => p.Bid).DefaultIfEmpty(0).Max(),
                                    Low = g.Select(p => p.Bid).DefaultIfEmpty(0).Min(),
                                    Close = g.Select(p => p.Bid).DefaultIfEmpty(0).Last(),
                                    Time = g.Select(p => p.Time).First()
                                          });

return Enumerable.Range(0,(Int32)((endofLoopDate.Ticks - beginDate.Ticks)/timeSpan.Ticks))
                 .Select(i => rawGroups.Keys.Contains(i) ? 
                              rawGroups[i] :
                              new OHLC()
                              {
                               Open = 0,
                               High = 0,
                               Low = 0,
                               Close = 0,
                               Time = new DateTime(beginDate.Ticks + k*timeSpan.Ticks)
                              }).ToList();

var rawGroups=fileRawList.Where（file=>file.Time>=beginDate）
.Where（file=>file.Timefile.Time）
.ToLookup（file=>（file.Time.Ticks-beginDate.Ticks）/timeSpan.Ticks，
file=>new{Bid=file.Bid，Time=file.Time}）
.ToDictionary（g=>g.Key，g=>newOHLC（）
{
Open=g.Select（p=>p.Bid）.DefaultIfEmpty（0）.First（），
High=g.Select（p=>p.Bid）.DefaultIfEmpty（0）.Max（），
Low=g.Select（p=>p.Bid）.DefaultIfEmpty（0）.Min（），
Close=g.Select（p=>p.Bid）.DefaultIfEmpty（0）.Last（），
Time=g.Select（p=>p.Time）.First（）
});
返回可枚举的.Range（0，（Int32）（（endofloupdate.Ticks-beginDate.Ticks）/timeSpan.Ticks））
.Select（i=>rawGroups.Keys.Contains（i）？
小组[i]：
新的OHLC（）
{
打开=0，
高=0，
低=0，
关闭=0，
时间=新日期时间（beginDate.Ticks+k*timeSpan.Ticks）
}).ToList（）；

备选方案：

var result = Enumerable.Range(0,(Int32)((endofLoopDate.Ticks - beginDate.Ticks)/timeSpan.Ticks))
                       .GroupJoin(fileRawList.Where(file => file.Time >= beginDate)
                                             .Where(file => file.Time < endofLoopDate)
                                             .OrderBy(file => file.Time),
                                  i => i,
                                  file => (file.Time.Ticks - beginDate.Ticks) / timeSpan.Ticks,
                                  (k,g) => new OHLC()
                                      {
                                       Open = g.Select(p => p.Bid).DefaultIfEmpty(0).First(),
                                       High = g.Select(p => p.Bid).DefaultIfEmpty(0).Max(),
                                       Low = g.Select(p => p.Bid).DefaultIfEmpty(0).Min(),
                                       Close = g.Select(p => p.Bid).DefaultIfEmpty(0).Last(),
                                       Time = g.Any() ? 
                                         g.Select(p => p.Time).First() :
                                         new DateTime(beginDate.Ticks + i*timeSpan.Ticks)
                                      })

var result=Enumerable.Range（0，（Int32）（（endofloupdate.Ticks-beginDate.Ticks）/timeSpan.Ticks））
.GroupJoin（fileRawList.Where（file=>file.Time>=beginDate）
.Where（file=>file.Timefile.Time），
i=>i，
file=>（file.Time.Ticks-beginDate.Ticks）/timeSpan.Ticks，
（k，g）=>新的OHLC（）
{
Open=g.Select（p=>p.Bid）.DefaultIfEmpty（0）.First（），
High=g.Select（p=>p.Bid）.DefaultIfEmpty（0）.Max（），
Low=g.Select（p=>p.Bid）.DefaultIfEmpty（0）.Min（），
Close=g.Select（p=>p.Bid）.DefaultIfEmpty（0）.Last（），
时间=g.Any（）？
g、 选择（p=>p.Time）.First（）
新日期时间（beginDate.Ticks+i*timeSpan.Ticks）
})

有几处错误，但总体上感谢您的想法非常有用，干杯们，您可以编辑或启发我，以便更严格地回答问题吗？我指的是我无法解决的错误。在第一个示例中，g=>new OHLC（）生成错误：无法将lambda表达式转换为类型“System.Collections.Generic.IEqualityComparer”，因为它不是委托类型，而第二个：“System.Linq.ILookup”不包含“ApplyResultSelector”的定义，并且找不到接受“System.Linq.ILookup”类型的第一个参数的扩展方法“ApplyResultSelector”（是否缺少using指令或程序集引用？），我不知道我做错了什么？我认为应该将此参数转换为（int）属性的第二个参数，例如：Enumerable.Range（0，（int）（endofloupdate.Ticks-beginDate.Ticks）/timeSpan.Ticks）

var result = Enumerable.Range(0,(Int32)((endofLoopDate.Ticks - beginDate.Ticks)/timeSpan.Ticks))
                       .GroupJoin(fileRawList.Where(file => file.Time >= beginDate)
                                             .Where(file => file.Time < endofLoopDate)
                                             .OrderBy(file => file.Time),
                                  i => i,
                                  file => (file.Time.Ticks - beginDate.Ticks) / timeSpan.Ticks,
                                  (k,g) => new OHLC()
                                      {
                                       Open = g.Select(p => p.Bid).DefaultIfEmpty(0).First(),
                                       High = g.Select(p => p.Bid).DefaultIfEmpty(0).Max(),
                                       Low = g.Select(p => p.Bid).DefaultIfEmpty(0).Min(),
                                       Close = g.Select(p => p.Bid).DefaultIfEmpty(0).Last(),
                                       Time = g.Any() ? 
                                         g.Select(p => p.Time).First() :
                                         new DateTime(beginDate.Ticks + i*timeSpan.Ticks)
                                      })