C# 此数组方法将继续更新[0]索引，还是将上一个文本向后移动？

我有一个方法每600000毫秒引入一次文本，它通过以下方法添加到数组中：

String[] namesArray = { };
Array.Resize(ref namesArray, namesArray.Length + 1);
namesArray[namesArray.Length - 1] = nameSplit;

我很好奇，这只是用新文本替换数组，还是将旧索引向上推。例如，如果发送的文本是

Jim

，是否将其放在[0]中。当下一个是“哈利”时，“吉姆”会被推到，而“哈利”会被推到[0]。如果需要更多代码，请告诉我

编辑

---

以下是您的代码的作用：

String[] namesArray = { };                         // Create a new zero-element array.
Array.Resize(ref namesArray, namesArray.Length + 1);   // Increase size of array by 1.
namesArray[namesArray.Length - 1] = nameSplit;      // Assign to array's last element.

因此，最终结果是您将拥有一个单元素数组，其内容是

nameSplit

变量。这相当于：

String[] namesArray = { nameSplit };

---

后续调用将导致创建一个新的单元素数组，并将其分配给

namesArray

以下是代码的操作：

String[] namesArray = { };                         // Create a new zero-element array.
Array.Resize(ref namesArray, namesArray.Length + 1);   // Increase size of array by 1.
namesArray[namesArray.Length - 1] = nameSplit;      // Assign to array's last element.

因此，最终结果是您将拥有一个单元素数组，其内容是

nameSplit

变量。这相当于：

String[] namesArray = { nameSplit };

---

后续调用将导致创建一个新的单元素数组，并将其分配给

namesArray

以下是代码的操作：

String[] namesArray = { };                         // Create a new zero-element array.
Array.Resize(ref namesArray, namesArray.Length + 1);   // Increase size of array by 1.
namesArray[namesArray.Length - 1] = nameSplit;      // Assign to array's last element.

因此，最终结果是您将拥有一个单元素数组，其内容是

nameSplit

变量。这相当于：

String[] namesArray = { nameSplit };

---

后续调用将导致创建一个新的单元素数组，并将其分配给

namesArray

以下是代码的操作：

String[] namesArray = { };                         // Create a new zero-element array.
Array.Resize(ref namesArray, namesArray.Length + 1);   // Increase size of array by 1.
namesArray[namesArray.Length - 1] = nameSplit;      // Assign to array's last element.

因此，最终结果是您将拥有一个单元素数组，其内容是

nameSplit

变量。这相当于：

String[] namesArray = { nameSplit };

---

后续调用将导致创建一个新的一个元素数组，并将其分配给NAMESARTS/<代码> .< /P>

，而不是手动调整数组大小，而是考虑使用<代码>列表< /代码>。它基本上是一个自动调整大小的数组。与其使用两个数组，一个用于名称，另一个用于金额，不如创建一个将名称和金额分组在一起的结构或类，以便使用单个列表：

public struct NameAndAmount
{
    public string Name;
    public int Amount;

    public NameAndAmount(string name, int amount)
    {
        Name = name;
        Amount = amount;
    }
}

List<NameAndAmount> items = new List<NameAndAmount>();
items.Add(new NameAndAmount("test", 100));

公共结构名称和装载
{
公共字符串名称；
公共整数金额；
公共名称和装载量（字符串名称，整数金额）
{
名称=名称；
金额=金额；
}
}
列表项=新列表（）；
增加（新名称和数量（“测试”，100））；

但是，如果需要按名称执行查找，则可能需要使用

字典

，使用名称作为键，使用金额作为值：

Dictionary<string, int> items = new Dictionary<string, int>();

// Check if a name has been stored before:
if (items.ContainsKey(name))
    int previousAmount = items[name];

// Store a name and amount:
items[name] = amount;

Dictionary items=newdictionary（）；
//检查在以下情况之前是否存储了名称：
if（项目.容器（名称））
int previousAmount=项目[名称]；
//存储名称和金额：
项目[名称]=金额；
< /代码> 而不是手动调整数组大小，而是考虑使用<代码>列表< /代码>。它基本上是一个自动调整大小的数组。与其使用两个数组，一个用于名称，另一个用于金额，不如创建一个将名称和金额分组在一起的结构或类，以便使用单个列表：

public struct NameAndAmount
{
    public string Name;
    public int Amount;

    public NameAndAmount(string name, int amount)
    {
        Name = name;
        Amount = amount;
    }
}

List<NameAndAmount> items = new List<NameAndAmount>();
items.Add(new NameAndAmount("test", 100));

公共结构名称和装载
{
公共字符串名称；
公共整数金额；
公共名称和装载量（字符串名称，整数金额）
{
名称=名称；
金额=金额；
}
}
列表项=新列表（）；
增加（新名称和数量（“测试”，100））；

但是，如果需要按名称执行查找，则可能需要使用
字典
，使用名称作为键，使用金额作为值：

Dictionary<string, int> items = new Dictionary<string, int>();

// Check if a name has been stored before:
if (items.ContainsKey(name))
    int previousAmount = items[name];

// Store a name and amount:
items[name] = amount;

Dictionary items=newdictionary（）；
//检查在以下情况之前是否存储了名称：
if（项目.容器（名称））
int previousAmount=项目[名称]；
//存储名称和金额：
项目[名称]=金额；
< /代码> 而不是手动调整数组大小，而是考虑使用<代码>列表< /代码>。它基本上是一个自动调整大小的数组。与其使用两个数组，一个用于名称，另一个用于金额，不如创建一个将名称和金额分组在一起的结构或类，以便使用单个列表：

public struct NameAndAmount
{
    public string Name;
    public int Amount;

    public NameAndAmount(string name, int amount)
    {
        Name = name;
        Amount = amount;
    }
}

List<NameAndAmount> items = new List<NameAndAmount>();
items.Add(new NameAndAmount("test", 100));

公共结构名称和装载
{
公共字符串名称；
公共整数金额；
公共名称和装载量（字符串名称，整数金额）
{
名称=名称；
金额=金额；
}
}
列表项=新列表（）；
增加（新名称和数量（“测试”，100））；

但是，如果需要按名称执行查找，则可能需要使用
字典
，使用名称作为键，使用金额作为值：

Dictionary<string, int> items = new Dictionary<string, int>();

// Check if a name has been stored before:
if (items.ContainsKey(name))
    int previousAmount = items[name];

// Store a name and amount:
items[name] = amount;

Dictionary items=newdictionary（）；
//检查在以下情况之前是否存储了名称：
if（项目.容器（名称））
int previousAmount=项目[名称]；
//存储名称和金额：
项目[名称]=金额；
< /代码> 而不是手动调整数组大小，而是考虑使用<代码>列表< /代码>。它基本上是一个自动调整大小的数组。与其使用两个数组，一个用于名称，另一个用于金额，不如创建一个将名称和金额分组在一起的结构或类，以便使用单个列表：

public struct NameAndAmount
{
    public string Name;
    public int Amount;

    public NameAndAmount(string name, int amount)
    {
        Name = name;
        Amount = amount;
    }
}

List<NameAndAmount> items = new List<NameAndAmount>();
items.Add(new NameAndAmount("test", 100));

公共结构名称和装载
{
公共字符串名称；
公共整数金额；
公共名称和装载量（字符串名称，整数金额）
{
名称=名称；
金额=金额；
}
}
列表项=新列表（）；
增加（新名称和数量（“测试”，100））；

但是，如果需要按名称执行查找，则可能需要使用
字典
，使用名称作为键，使用金额作为值：

Dictionary<string, int> items = new Dictionary<string, int>();

// Check if a name has been stored before:
if (items.ContainsKey(name))
    int previousAmount = items[name];

// Store a name and amount:
items[name] = amount;

Dictionary items=newdictionary（）；
//检查在以下情况之前是否存储了名称：
if（项目.容器（名称））
int previousAmount=项目[名称]；
//存储名称和金额：
项目[名称]=金额；
让我们知道你为什么不试试。。（提示：如果你真的感兴趣的话，你可以加快这个过程！）我不能，我有大量的代码。我只是需要一个了解算法的人来帮助我。我不知道它是否只是在替换[0]indexI假设
String[]namesArray={}仅在初始化时执行，而不是在其他两行中执行？如果没有，你只会