C# 大型数据集的数据结构

我需要为一个类创建一个高效的数据结构，该类存储大小从50000到100000的值的集合

class TypeData
{
    public string Name { get; set; }
    public Collection<double> Data{ get; set; }
}

现在，用户希望恢复该操作。然后我必须删除所有的0.0，并将原始值放在集合中的这些索引上

问题1： 如何跟踪已更改的索引？我是否需要保存另一个包含所有已更改索引的列表？ 问题2： 如何改进该类的数据结构，使其能够容纳数千个实例，即

List dataList=newlist（）//此列表的大小可以增加到5000

问题1：如何跟踪已更改的索引？我需要留一张支票吗
另一个包含所有已更改索引的列表

我不会存储
集合
，而是存储值、当前状态和历史记录（如果有）的
集合

例如：

public class TypeData
{
    public string Name { get; set; }
    public List<Data> Data { get; set; }
}

public class Data
{
    public enum State
    {
        Unassigned,
        Original,
        Modified
    }

    private double _Value = 0.0d;
    public double Value
    {
        get { return _Value; }
        set
        {
            if (CurrentState == State.Unassigned)
                CurrentState = State.Original;
            else
                CurrentState = State.Modified;
            _Value = value;
            _ValueHistory.Add(value);
            if (_ValueHistory.Count > MaxHistoryCount)
                ClearValueHistory();
        }
    }

    private List<double> _ValueHistory = new List<double> { 0.0d };
    private List<double> ValueHistory
    {
        get { return _ValueHistory; }
        set { _ValueHistory = value; }
    }

    private int _MaxHistoryCount = int.MaxValue;
    public int MaxHistoryCount
    {
        get { return _MaxHistoryCount; }
        set { _MaxHistoryCount = value; }
    }

    public void ClearValueHistory()
    {
        if (_ValueHistory.Count > 1)
            _ValueHistory.RemoveRange(0, _ValueHistory.Count - 1); // keep last
    }

    private State _CurrentState = State.Unassigned;
    public State CurrentState
    {
        get { return _CurrentState; }
        private set { _CurrentState = value; }
    }

    public void RevertOperation(int numRevertCount = 1)
    {
        int newRevisionIndex = _ValueHistory.Count - 1 - numRevertCount;
        if (newRevisionIndex < 0) newRevisionIndex = 0;
        double val = _ValueHistory[newRevisionIndex];
        _ValueHistory.RemoveRange(newRevisionIndex + 1, _ValueHistory.Count - 1 - newRevisionIndex);
        this._Value = val;
    }

    public override string ToString()
    {
        return Value.ToString();
    }
}

公共类类型数据
{
公共字符串名称{get；set；}
公共列表数据{get；set；}
}
公共类数据
{
公共枚举状态
{
未分配，
起初的
被改进的
}
专用双_值=0.0d；
公共双重价值
{
获取{返回_值；}
设置
{
if（CurrentState==State.Unassigned）
当前状态=状态。原始；
其他的
CurrentState=State.Modified；
_价值=价值；
_ValueHistory.Add（值）；
如果（_ValueHistory.Count>MaxHistoryCount）
ClearValueHistory（）；
}
}
私有列表_ValueHistory=新列表{0.0d}；
私人清单价值历史记录
{
获取{return\u ValueHistory；}
设置{u ValueHistory=value；}
}
私有int_MaxHistoryCount=int.MaxValue；
公共整数MaxHistoryCount
{
获取{return\u MaxHistoryCount；}
设置{u MaxHistoryCount=value；}
}
public void ClearValueHistory（）
{
如果（_ValueHistory.Count>1）
_ValueHistory.RemoveRange（0，_ValueHistory.Count-1）；//保留最后一个
}
私有状态_CurrentState=状态。未分配；
公共状态当前状态
{
获取{return\u CurrentState；}
私有集{u CurrentState=value；}
}
公共无效还原操作（int numevertcount=1）
{
int newRevisionIndex=\u ValueHistory.Count-1-numRevertCount；
如果（newRevisionIndex<0）newRevisionIndex=0；
double val=_ValueHistory[newRevisionIndex]；
_ValueHistory.RemoveRange（newRevisionIndex+1，_ValueHistory.Count-1-newRevisionIndex）；
该值为._值=val；
}
公共重写字符串ToString（）
{
返回值.ToString（）；
}
}

以下是示例数据和示例反向操作：

var listOfData = new List<TypeData>{ 
    new TypeData {
        Name = "TestData",
        Data = new List<Data> 
        {
            new Data { Value = 1.5 }, new Data { Value = 2.4 }, new Data { Value = 1.2 },  new Data(),
            new Data { Value = 0.7 }, new Data { Value = -4.7 }, new Data { Value = 0.0 }, new Data { Value = 4711}
        }
    }
};

foreach (var td in listOfData)
{
    foreach (var data in td.Data.Take(10))
    {
        data.Value = 4711.4711;
    }
}
foreach (var td in listOfData)
{
    foreach (var data in td.Data.Take(10))
    {
        data.RevertOperation();
    }
}

var listOfData=新列表{
新类型数据{
Name=“TestData”，
数据=新列表
{
新数据{Value=1.5}，新数据{Value=2.4}，新数据{Value=1.2}，新数据（），
新数据{Value=0.7}，新数据{Value=-4.7}，新数据{Value=0.0}，新数据{Value=4711}
}
}
};
foreach（listOfData中的var td）
{
foreach（td.data.Take（10）中的var数据）
{
数据值=4711.4711；
}
}
foreach（listOfData中的var td）
{
foreach（td.data.Take（10）中的var数据）
{
data.RevertOperation（）；
}
}

问题2：如何改进该类的数据结构，使其
可容纳数千个实例，即

你为什么需要改进它？我会保持原样。我怀疑它需要太多的记忆。否则，您应该决定是购买更多内存还是改用数据库。
如果只需撤消一次操作，则保留Tim Schmelter的活动/实际值的解决方案是正确的

如果需要多个撤消，那么必须实现一个历史记录。同样，您也可以提供重做的可能性

通过一些假设，撤销实际上是一项非常简单的任务。如果撤消之间列表中的项目数没有更改，则可以将所有更改保存在历史记录（基本上是另一个列表）
索引
和
值
。撤消操作将遍历历史记录，获取索引并仅恢复值

如果要更改项目的数量，则最简单的方法是通过制作副本来保存数据的完整状态。然而，这是内存消耗操作，但是如果您考虑使用数据库或文件来保存这些状态，仍然可以实现。
另一个解决方案是实现操作，您可以将其保存在历史记录中。您仍然需要保存状态，但它将仅具有该大小，这是必需的操作（例如，在删除项的情况下，您不需要存储整个列表，只存储已删除项的索引和值）。在这种情况下，“撤消”看起来像是从历史记录中读取最后一个操作并向后执行（或者您可以从“开始”开始反转历史记录，准备撤消，例如，在删除项的情况下，您可以保存“插入”操作）。在列表操作的情况下，可能操作的基本列表可以是：clear、insert at、delete at、change value at。
我本可以使用struct，用一个布尔值表示更改的值。但我有一些硬性要求，有两种类型的操作，第一种操作将在随机索引中将值标记为0.0，第二种操作将在索引范围内将值标记为0.0。所以，如果用户只想恢复第一个操作，该怎么办。boolean无法判断，是什么操作将此值设置为0.0enum数据类型{Original，Operation1，Operation2}结构数据{double value；DataType；}这是否可行？如果将来有新的需求，或者可能是第三次操作，该怎么办？老实说，我会使用数据库。但是，我编辑了我的答案，以显示
var listOfData = new List<TypeData>{ 
    new TypeData {
        Name = "TestData",
        Data = new List<Data> 
        {
            new Data { Value = 1.5 }, new Data { Value = 2.4 }, new Data { Value = 1.2 },  new Data(),
            new Data { Value = 0.7 }, new Data { Value = -4.7 }, new Data { Value = 0.0 }, new Data { Value = 4711}
        }
    }
};

foreach (var td in listOfData)
{
    foreach (var data in td.Data.Take(10))
    {
        data.Value = 4711.4711;
    }
}
foreach (var td in listOfData)
{
    foreach (var data in td.Data.Take(10))
    {
        data.RevertOperation();
    }
}