每隔5分钟存一次数据，不难但有点绕，怎么设计最合理，大侠进

Question

商品肯定唯一，用ConcurrentDictionary<T1,T2>存储商品及对应的最高价和最低价
然后timer定时执行sql

Answer 1

做个你要的数据结构类，然后每个要的品种实例为一个类，直接放入SortedList中进行缓存，也占不了几个内存。
每次更新对应的对象即可，如果有需要的运算，在数据类中进行处理，结构清晰简单，完全不需要存入数据库，你想入库增加个入库函数即可。你是在做金融股票行情吧，是这个的话，最好数据全部缓存，数据库操作太频繁，反应速度会不够。

Answer 2

现在有“Rx”异步编程
以前这坛子里有人发了个帖子，我记不得地址了，不过当时把代码存了一份，这里就借花献佛了
  public partial class Form1 : Form
    {   // 通过事件来创建真数据的可观察源
            
        RealDataProducer real = new RealDataProducer();
        public Form1()
        {
            InitializeComponent();
        }        private void button1_Click(object sender, EventArgs e)
        {
         
         
            var realSource = Observable.FromEvent<MyData>(a => real.OnData += a, a => real.OnData -= a);            // 每两秒生成假数据的可观察源
            var dummySource = Observable.Interval(TimeSpan.FromSeconds(2))
                .Select(_ => new MyData { IsDummy = true, Timestamp = DateTime.Now, Value = 0 });
            
          
            
            var n = 5;
            // 合并真假源，取每1s的时间窗口内的数据，如果存在真数据，就把假数据剔除（这样理论上相邻数据之间的间隔不会超过3s）
            // 缓存每n秒的数据订阅输出（一次写多条数据到数据库性能好点）         
            var sub = realSource.Merge(dummySource).Buffer(TimeSpan.FromSeconds(1)).SelectMany(buf =>
            {
                if (buf.Any(d => !d.IsDummy))
                    buf = buf.Where(d => !d.IsDummy).ToList();
                return buf;
            }).Buffer(TimeSpan.FromSeconds(n)).Subscribe(buf =>
            {
                // 订阅数据，输出（或保存到数据库）
                foreach (var d in buf)
                {                    this.textBox1.Invoke(new Set_Text(setText),d);
              
                }
            });
            real.Start(); // 启动真实数据接收
        }        public delegate void Set_Text(MyData d);
        public void setText(MyData d)
        {
           
            this.textBox1.Text += String.Format("{0} {1} {2} {3}", d.Timestamp.ToString("mm:ss.fff"), d.IsDummy ? "D" : "R", d.Value, Environment.NewLine);
        }        public class MyData
        {
            /// <summary>是否为假数据</summary>
            public bool IsDummy { get; set; }            /// <summary>时间戳</summary>
            public DateTime Timestamp { get; set; }            /// <summary>数据值</summary>
            public int Value { get; set; }
        }        /// <summary>模拟真实数据生成</summary>
        public class RealDataProducer
        {
            private readonly CancellationTokenSource _cts = new CancellationTokenSource();
            private readonly Random _rnd = new Random();            public event Action<MyData> OnData;            private MyData Produce()
            {
                return new MyData { Timestamp = DateTime.Now, Value = _rnd.Next(100) };
            }            public void Start()
            {
                // 80%概率在3s-5s后取得下一数据，20%概率在0s-1s后取得下一数据
                // 取到数据时触发OnData事件
                var ct = _cts.Token;
                var task = new Task(() =>
                {
                    while (!ct.IsCancellationRequested)
                    {
                        if (OnData != null)
                            OnData(Produce());
                        Thread.Sleep(_rnd.NextDouble() < 0.8f ? _rnd.Next(3000, 5000) : _rnd.Next(0, 1000));
                    }
                }, ct, TaskCreationOptions.LongRunning);
                task.Start();
            }            public void Stop()
            {
                _cts.Cancel();
            }
        }        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            real.Stop();
        }
    }

Answer 3

ConcurrentDictionary<T1,T2>
AddOrUpdate(TKey, TValue, Func<TKey, TValue, TValue>) 如果该键尚不存在，则将键/值对添加到 ConcurrentDictionary<TKey, TValue>；如果该键已存在，则使用指定函数更新 ConcurrentDictionary<TKey, TValue> 中的键/值对这个就比hashtable之类的好多了，省去了判断键是否存在

Answer 4

依据逻辑写代码顺理成章,什么是麻烦什么是不麻烦.
解决办法很简单,存储每次进来的数据,然后删除超过5分钟的数据,然后统计.
存储可以用DataTable, HashTable,字典,List等等.