利用队列[关闭]

Question

我正在尝试按类别存储过去 1、7、30 或 360 天的所有交易记录。我尝试了几件事，但它们都失败了。我有一个想法，使用具有 360 个值的队列，每天一个，但我对队列的了解不够，无法弄清楚它是如何工作的。

输入将是此类的一个实例：

class Transaction
{
    public string TotalEarned { get; set; }
    public string TotalHST { get; set; }
    public string TotalCost { get; set; }
    public string Category { get; set; }
}

一天中的任何时间都可能发生新的交易，一天最多可以有 15 笔交易。我的程序使用纯文本文件作为外部存储，但我如何加载它取决于我决定如何存储这些数据。

最好的方法是什么？

Answer 1

我不确定队列是否正是您在此处寻找的。队列是一种短暂的数据结构：它的目的不是让事情暂时存在，当然也不是为了让您以您想要的方式对数据进行切片和切块。

听起来您的用例急需数据库。长期存储结构化数据，以按各种标准进行排序或查询，这正是数据库的发明目的。

Answer 2

您显然追求的是便利而不是速度。您期望的典型用法总共存储大约 5400 笔交易。这真的很小，单个ArrayList 应该没问题。当您想从中查询数据时，只需遍历它，将相关项目添加到另一个 ArrayList 并返回。

只需按排序顺序保存您的数据 - 即所有新交易都会被推到列表的后面。如果你想按类别拉出，那应该和按天拉出一样简单。

保持单一结构并从中复制查询将使您的生活更轻松，尤其是当您的类在多个线程中使用并需要锁定时。

对我来说，维护索引以加快查找速度或使用数据库似乎有点过头了。如果一个简单的解决方案足够好，那么就使用它。它更易于维护且不易出错。

Answer 3

在决定数据存储之前，您应该考虑要对数据执行的操作。对我来说，听起来你想要

• 按日期和时间段查询
• 让集合根据其包含的数据的年龄自行清除

编写一个自定义类来执行您需要的操作（仅此而已）并使用适当类型的后备存储。

类似这样的：

class MyTransactions
{
  private DateTime? OldestDate   { get ; set ; }
  private Dictionary<DateTime,List<Transaction>> BackingStore { get ; set ; }
  private int RetentionPeriodInDays
  {
    get
    {
      DateTime now     = DateTime.Now.Date ;
      TimeSpan oneYear = now - now.AddYears(-1) ;
      int      days    = (int) oneYear.TotalDays ;
      return days ;
    }
  }

  public MyTransactions()
  {
    OldestDate = null ;
    BackingStore = new Dictionary<DateTime,List<Transaction>>();
  }

  public void Add( Transaction t )
  {
    if ( t == null ) throw new ArgumentNullException("t");

    if ( this.BackingStore.Count > RetentionPeriodInDays )
    {
      this.BackingStore.Remove(this.OldestDate.Value ) ;
      this.OldestDate = this.BackingStore.Keys.Min() ;
    }

    DateTime today = DateTime.Now.Date ;
    List<Transaction> transactions ;
    bool exists = this.BackingStore.TryGetValue(today,out transactions) ;
    if ( !exists )
    {
      transactions = new List<Transaction>();
      this.BackingStore.Add(today,transactions) ;
    }
    transactions.Add(t) ;

    if ( today < this.OldestDate )
    {
      this.OldestDate = today ;
    }

    return ;
  }

  public List<Transaction> TodaysData
  {
    get
    {
      DateTime today = DateTime.Now.Date ;
      List<Transaction> value = new List<Transaction>( this.BackingStore[today] ) ;
      return value ;
    }
  }

  public List<Transaction> CurrentWeekData
  {
    get
    {
      DateTime today = DateTime.Now.Date ;
      List<Transaction> value = this.BackingStore
                                    .Where( x => x.Key > today.AddDays(-7) )
                                    .SelectMany( x => x.Value )
                                    .ToList()
                                    ;
      return value ;
    }
  }

}

Answer 4

这是一个跟踪在特定时期内添加到其中的元素的类。要使用它：

    // creating
    var q = new RecentQueue<Transaction>(TimeSpan.FromDays(360)); // last 360 days
    var q = new RecentQueue<Transaction>(TimeSpan.FromSeconds(5)) // last 5 seconds

    // adding elements
    var t = new Transaction { Category = "cat1", TotalCost = "5",
                                TotalEarned = "3", TotalHST = "2" }
    q.Enqueue(t);

    // iterating 
    foreach (var element in q)
        // do whatever

代码：

using System;
using System.Collections;
using System.Collections.Generic;

namespace MyCollections
{
    public class RecentQueue<T> : IEnumerable<T>
    {
        class RecentItem<U>
        {
            public U Item { get; set; }
            public DateTime Date { get; set; }
        }

        public TimeSpan Period { get; set; }
        private Queue<RecentItem<T>> _q;

        public RecentQueue(TimeSpan t)
        {
            Period = t;
            _q = new Queue<RecentItem<T>>();
        }

        public void Enqueue(T t)
        {
            Enqueue(t, DateTime.Now);
        }

        public void Enqueue(T t, DateTime date)
        {
            Cut();
            _q.Enqueue(new RecentItem<T> { Date = date, Item = t });
        }

        public IEnumerator<T> GetEnumerator()
        {
            Cut();
            foreach (var element in _q)
                yield return element.Item;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            Cut();
            foreach (var element in _q)
                yield return element.Item;    
        }

        private void Cut()
        {
            var date = DateTime.Now;
            while (_q.Count > 0 && date - _q.Peek().Date > Period)
                _q.Dequeue();
        }
    }
}

但是，我同意 couchand 的观点，“真正的”解决方案不是这个，也不是任何其他内存数据结构。它只是使用数据库，在日期上对其进行索引并进行查询。

我发布的课程实际上对于一些在短时间内（最后几秒钟等）跟踪快速发生事件的应用程序更有用，因为这样你就不想用请求打击数据库，你想要高性能，而且您不关心保存数据。

如果您要跟踪 360 天的数据，您需要一个数据库。

Answer 5

如果您要采用“每天一个时段”的方法，一个选项是二维数组。一个长度为 365 的数组，该数组中的每个插槽都有自己的数组或列表结构来跟踪当天的交易。

如何保存？我会使用 XML，但这只是个人喜好，因为我在 C# 中序列化和反序列化 XML 方面有很多经验。

或者正如另一个答案所说，数据库非常适合您在结构方面寻找的内容。取决于这个项目的规模。

编辑：将答案从哈希表更改为二维数组。