C# 始终将数据[0]作为最新数据访问

我有一个由一百万个元素组成的数组，我将把它模拟成实时数据，通过将当前索引设为“立即”并增加它来模拟新的数据

我将对现在的数据和过去的数据进行大量计算

我想知道是否有一种方便的方法可以将其抽象为访问someDataType[0]和1 bar前的数据，例如someDataType[1]等等

我是编程新手，所以我不确定什么是可能的，什么是不可能的。理想情况下，此数据类型不必将数据从数组复制到数据类型，而是可以存储所有数据本身并跳过数组或以某种方式指向数组。而且它肯定必须能够以与数组相同的方式访问数据，而不必像列表那样通过自身迭代来访问某个点

---

我真的不知道这在任何方式、形状或形式上是否可能。我这样问。谢谢你的意见！：）

听起来您需要对结构进行动态调整，因此可以在System.Collections.Generic命名空间中找到一个不错的选择

var list = new List<int>();
list.Add(1); // keep adding

而且使用它很简单

var myList = new List<int>() { 1, 2, 3, 4, 5 };
int item = myList.FromEnd(1);
Debug.Assert(item == 4);

var myList=newlist（）{1,2,3,4,5}；
int item=myList.FromEnd（1）；
断言（项==4）；

---

当然，这里的问题是，如果您想在

foreach

中循环它，它本身就不适合（您仍然可以在

中使用标准的
）。如果使用foreach，您可以简单地循环使用
foreach（myList.Reverse（）中的var项）{}
，或者您可以使用svick答案中编码的方法。
听起来您需要对结构进行动态调整，因此在System.Collections.Generic命名空间中可以找到一个很好的选择

var list = new List<int>();
list.Add(1); // keep adding

而且使用它很简单

var myList = new List<int>() { 1, 2, 3, 4, 5 };
int item = myList.FromEnd(1);
Debug.Assert(item == 4);

var myList=newlist（）{1,2,3,4,5}；
int item=myList.FromEnd（1）；
断言（项==4）；

当然，这里的问题是，如果您想在
foreach
中循环它，它本身就不适合（您仍然可以在
中使用标准的
）。如果使用foreach，您可以简单地循环使用
foreach（myList.Reverse（）中的var项）{}
，或者您可以使用svick答案中编码的方法。
首先，如果您想添加新项，那么直接使用数组可能不是最佳选择（除非最新项应该覆盖最旧项）。更好的选择是
列表

现在，您要创建的是一个“反向”集合：它将包含一个
列表
和：


其索引器将访问支持列表中的反向索引
它的add方法（可能称为
AddFirst（）
）将添加到列表的末尾
它的
GetEnumerator（）
方法将返回反向枚举数

随着所有这些需求的充实，代码几乎可以自己编写：

class AddFirstList<T> : IEnumerable<T>, IReadOnlyList<T>
{
    private readonly List<T> m_list = new List<T>();

    public void AddFirst(T item)
    {
        m_list.Add(item);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return Enumerable.Reverse(m_list).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public int Count
    {
        get { return m_list.Count; }
    }

    public T this[int index]
    {
        get { return m_list[Count - index - 1]; }
    }
}

类AddFirstList:IEnumerable，IReadOnlyList
{
私有只读列表m_List=新列表（）；
公共无效添加第一项（T项）
{
m_列表。添加（项目）；
}
公共IEnumerator GetEnumerator（）
{
返回可枚举的.Reverse（m_list）.GetEnumerator（）；
}
IEnumerator IEnumerable.GetEnumerator（）
{
返回GetEnumerator（）；
}
公共整数计数
{
获取{return m_list.Count；}
}
公共T此[int索引]
{
获取{return m_list[Count-index-1]；}
}
}

（如果您不在.Net 4.5上，请删除
IReadOnlyList
界面。）
首先，如果您想添加新项目，那么直接使用数组可能不是最佳选择（除非最新项目应该覆盖最旧的项目）。更好的选择是
列表

现在，您要创建的是一个“反向”集合：它将包含一个
列表
和：


其索引器将访问支持列表中的反向索引
它的add方法（可能称为
AddFirst（）
）将添加到列表的末尾
它的
GetEnumerator（）
方法将返回反向枚举数

随着所有这些需求的充实，代码几乎可以自己编写：

class AddFirstList<T> : IEnumerable<T>, IReadOnlyList<T>
{
    private readonly List<T> m_list = new List<T>();

    public void AddFirst(T item)
    {
        m_list.Add(item);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return Enumerable.Reverse(m_list).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public int Count
    {
        get { return m_list.Count; }
    }

    public T this[int index]
    {
        get { return m_list[Count - index - 1]; }
    }
}

类AddFirstList:IEnumerable，IReadOnlyList
{
私有只读列表m_List=新列表（）；
公共无效添加第一项（T项）
{
m_列表。添加（项目）；
}
公共IEnumerator GetEnumerator（）
{
返回可枚举的.Reverse（m_list）.GetEnumerator（）；
}
IEnumerator IEnumerable.GetEnumerator（）
{
返回GetEnumerator（）；
}
公共整数计数
{
获取{return m_list.Count；}
}
公共T此[int索引]
{
获取{return m_list[Count-index-1]；}
}
}

（如果您不在.Net 4.5上，请删除
IReadOnlyList
接口。）
听起来您希望索引0是“当前数据”，而索引1是以前的数据

您可以通过编写自己的类来封装百万元素数组来实现这一点。然后您可以指定现在为
的索引
，并将其添加到每个索引中。例如：

public class DataArray
{
    readonly Object[] data;

    int rightNow;
    public int RightNow
    {
        get { return this.rightNow; }
        set { this.rightNow = value; }
    }

    public DataArrat(Object[] data)
    {
        // TODO: Check that data is not null.
        this.data = data;
    }

    // This is called an 'indexer':
    public Object this[int index]
    {
        get
        {
            // TODO: Check whether (index + this.rightNow) is in the valid range.
            return this.data[index + this.rightNow];
        }
    }
}

// Initialize the DataArray:
Object[] millionElementArray /* = from somewhere, e.g. */ = new []
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var data = new DataArray(millionElementArray);

// Start at bar 8:
data.RightNow = 8;

// Use the data:
Object currentData = data[0];
Object futureData = data[-1];
Object pastData = data[1];

// Go to the next bar:
data.RightNow--;

// Use the data:
Object currentData = data[0];
Object futureData = data[-1];
Object pastData = data[1];

// Rinse and repeat...

现在您可以这样使用它，例如：

public class DataArray
{
    readonly Object[] data;

    int rightNow;
    public int RightNow
    {
        get { return this.rightNow; }
        set { this.rightNow = value; }
    }

    public DataArrat(Object[] data)
    {
        // TODO: Check that data is not null.
        this.data = data;
    }

    // This is called an 'indexer':
    public Object this[int index]
    {
        get
        {
            // TODO: Check whether (index + this.rightNow) is in the valid range.
            return this.data[index + this.rightNow];
        }
    }
}

// Initialize the DataArray:
Object[] millionElementArray /* = from somewhere, e.g. */ = new []
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var data = new DataArray(millionElementArray);

// Start at bar 8:
data.RightNow = 8;

// Use the data:
Object currentData = data[0];
Object futureData = data[-1];
Object pastData = data[1];

// Go to the next bar:
data.RightNow--;

// Use the data:
Object currentData = data[0];
Object futureData = data[-1];
Object pastData = data[1];

// Rinse and repeat...

请注意，您应该用正在使用的数据类型替换
对象
，或者将类设置为泛型。
听起来您希望索引0为“当前数据”，索引1为以前的数据

您可以通过编写自己的类来封装百万元素数组来实现这一点。然后您可以指定现在为
的索引
，并将其添加到每个索引中。例如：

public class DataArray
{
    readonly Object[] data;

    int rightNow;
    public int RightNow
    {
        get { return this.rightNow; }
        set { this.rightNow = value; }
    }

    public DataArrat(Object[] data)
    {
        // TODO: Check that data is not null.
        this.data = data;
    }

    // This is called an 'indexer':
    public Object this[int index]
    {
        get
        {
            // TODO: Check whether (index + this.rightNow) is in the valid range.
            return this.data[index + this.rightNow];
        }
    }
}

// Initialize the DataArray:
Object[] millionElementArray /* = from somewhere, e.g. */ = new []
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var data = new DataArray(millionElementArray);

// Start at bar 8:
data.RightNow = 8;

// Use the data:
Object currentData = data[0];
Object futureData = data[-1];
Object pastData = data[1];

// Go to the next bar:
data.RightNow--;

// Use the data:
Object currentData = data[0];
Object futureData = data[-1];
Object pastData = data[1];

// Rinse and repeat...

现在您可以这样使用它，例如：

public class DataArray
{
    readonly Object[] data;

    int rightNow;
    public int RightNow
    {
        get { return this.rightNow; }
        set { this.rightNow = value; }
    }

    public DataArrat(Object[] data)
    {
        // TODO: Check that data is not null.
        this.data = data;
    }

    // This is called an 'indexer':
    public Object this[int index]
    {
        get
        {
            // TODO: Check whether (index + this.rightNow) is in the valid range.
            return this.data[index + this.rightNow];
        }
    }
}

// Initialize the DataArray:
Object[] millionElementArray /* = from somewhere, e.g. */ = new []
{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var data = new DataArray(millionElementArray);

// Start at bar 8:
data.RightNow = 8;

// Use the data:
Object currentData = data[0];
Object futureData = data[-1];
Object pastData = data[1];

// Go to the next bar:
data.RightNow--;

// Use the data:
Object currentData = data[0];
Object futureData = data[-1];
Object pastData = data[1];

// Rinse and repeat...

请注意，您应该用正在使用的数据类型替换
对象
，或者使类成为泛型类。
您做了什么？你能分享你的代码吗？好吧，我不能分享太多可以让问题更清楚的东西。我想要的最简单的解决方案是改变