如何从连续的数据c#中形成5分钟的开高低收盘值？ [关闭]

Question

我有一个 websocket api，它每秒不断地给我数据。我的目标是根据这些数据形成一个 5 分钟的开盘收盘价低点。

这是 Python 代码，它们在 Python 中也是如此：https://gist.github.com/oldmonkABA/f73f5d67bcf85316ac0470919bf54e17

我尝试如下OnTick 方法每 1 秒调用一次，每秒数据如下：

{"InstrumentToken":260105,"LastPrice":23616.6,"Timestamp":"2020-10-16T16:35:01"}

所以我会在每秒之后得到具有不同 LastPrice 和 Timestamp 的相同 json，例如：

{"InstrumentToken":260105,"LastPrice":23620,"Timestamp":"2020-10-16T14:38:02"}

{"InstrumentToken":260105,"LastPrice":23622,"Timestamp":"2020-10-16T14:38:03"}

以此类推，直到：

{"InstrumentToken":260105,"LastPrice":23644,"Timestamp":"2020-10-16T14:39:59"}

现在在下面的对象 latestTickData 我正在收集所有这些数据，预期的输出是：

open = 23616.6，因为它是基于“Timestamp”：“2020-10-16T14:35:01”的起始价格。

close = 23644，基于其最近 5 分钟的价格 "Timestamp":"2020-10-16T14:39:59"。

high = 我可以使用 MAX（所有 5 分钟数据）。

低 = 我可以使用 MIN（所有 5 分钟数据）

C#代码：

private static void OnTick(Tick TickData)
{
    Console.WriteLine("Tick " + Utils.JsonSerialize(TickData));

    var latestTickData = new MyObject()
    {
        InstrumentID = TickData.InstrumentToken,
        Close = TickData.LastPrice,
        High = TickData.LastPrice,
        Low = TickData.LastPrice,
        Open = TickData.LastPrice,
        TimeStamp = TickData.Timestamp.HasValue ? TickData.Timestamp.Value : DateTime.Now
    };

现在我将每秒收集一个新数据到latestTickData。

我想根据这个数据形成一个 5 分钟的开盘收盘高低。

我正在考虑对时间戳和 min max 函数进行类似 group by 以查找低位和高位，但代码不起作用。

我尝试使用此代码，但此代码超出 ontick 计算持续数据的方法：

var resultSet = MydataList.GroupBy(i => i.GetStartOfPeriodByMins(5))
           .Select(gr =>
          new
          {
              StartOfPeriod = gr.Key,
              Low = gr.Min(item => item.Low),
              High = gr.Max(item => item.High),
              Open = gr.OrderBy(item => item.TimeStamp).First().Open,
              Close = gr.OrderBy(item => item.TimeStamp).Last().Close
          });


public DateTime GetStartOfPeriodByMins(int numMinutes)
    {
        int oldMinutes = TimeStamp.Minute;
        int newMinutes = (oldMinutes / numMinutes) * numMinutes;

        DateTime startOfPeriod = new DateTime(TimeStamp.Year, TimeStamp.Month, TimeStamp.Day, TimeStamp.Hour, newMinutes, 0);

        return startOfPeriod;
    }

Answer 1

有很多方法可以做到这一点，这取决于您需要读取数据的频率，以及是否值得在每个滴答声中更新缓存，或者您需要一个计时器来保持刷新，或者您只是想计算它在飞行中。

无论如何，我选择了一个队列 来管理系列，我还选择了在每个滴答时更新缓存（正确或错误）。您可以轻松地使用列表，并实时过滤/查询，我将把所有这些细节留给您。

给定

public class Tick
{
   public int Instrument { get; set; }
   public DateTime TimeStamp { get; set; }
   public decimal LatestPrice { get; set; }
}

public class Data
{
   private readonly Queue<Tick> _queue = new Queue<Tick>();
   public decimal High { get; private set; }
   public decimal Low { get; private set; }
   public decimal Open { get; private set; }
   public decimal Close { get; private set; }

   public void Add(Tick tick)
   {
      _queue.Enqueue(tick);
      Update();
   }

   public void Update()
   {
      var age = DateTime.Now.AddMinutes(-5);
      while (_queue.Any() && _queue.Peek().TimeStamp < age)
         _queue.Dequeue();

      High = _queue.Max(x => x.LatestPrice);
      Low = _queue.Min(x => x.LatestPrice);
      Open = _queue.LastOrDefault()?.LatestPrice ?? 0;
      Close = _queue.FirstOrDefault()?.LatestPrice ?? 0;

   }
}

存放它的字典

private Dictionary<int,Data> _instruments = new Dictionary<int, Data>();

用法

// add data
if(!_instruments.TryGetValue(tick.Instrument, out var data))
   _instruments.Add(tick.Instrument, data = new Data());
data.Add(tick);

...

var Ohcl = _instruments[TickData.Instrument];

// example reading the data
Console.WriteLine(Ohcl.High);

如果你想即时计算

public class Data
{
   private readonly Queue<Tick> _queue = new Queue<Tick>();
   public decimal High => _queue.Max(x => x.LatestPrice);
   public decimal Low => _queue.Min(x => x.LatestPrice);
   public decimal Open => _queue.LastOrDefault()?.LatestPrice ?? 0;
   public decimal Close => _queue.FirstOrDefault()?.LatestPrice ?? 0;

   public void Add(Tick tick)
   {
      _queue.Enqueue(tick);
      Update();
   }

   public void Update()
   {
      var age = DateTime.Now.AddMinutes(-5);
      while (_queue.Any() && _queue.Peek().TimeStamp < age)
         _queue.Dequeue();
   }
}

_{注意：这并不是一个完整的解决方案，它缺乏健全性检查和一大堆可能与您相关的细节。性能和效率也由您自行决定}

Answer 2

编辑： 正如@Cid 所提到的，第一种方法假定数据是定期出现的，但很可能永远不会出现这种情况，并且很有可能出错。最好的方法是尝试第二种方法，其中有两个变量并进行比较时间戳。

---

这个问题有多种解决方法。你提到你每 1 秒获取一次数据，那么例如你可以有一个变量来计算你收集了多少条数据：

//before first element has come
int numberOfData=0;

并且在每个厚之后，您只需增加 numberOfData。当 numberOfData 为 300(5*60s) 时，假设您每隔一秒获取一次数据，那么五分钟过去了。

---

另一种方法是，您有两个变量 firstData 和 lastData，它们最初设置为 null。然后分配 firstData 的第一个 TickData，而不仅仅是比较 firstData 和即将到来的新 TickData 对象之间的时间戳。当差异是5 分钟后，您可以将该对象分配给 lastData。