C# 是否使用for循环将自定义对象指定给数组？

鉴于此：

我试过这样的方法：

for (int i = 0; i < dtable.Rows.Count; i++)
{
    DataRow drow = dtable.Rows[i];
    arrayOfCars[] =  new car(drow["make"].ToString(), drow["year"].ToString());
}

 List<car> cars= new List<car>()
 {
    new car("Ford",1992),
    new car("Fiat",1988),
    new car("Buick",1932),
    new car("Ford",1932),
    new car("Dodge",1999),
    new car("Honda",1977)
 };  //C# 3 collection initializer

for (int i = 0; i < dtable.Rows.Count; i++)
{
    DataRow drow = dtable.Rows[i];
    cars.Add(new car((string)drow["make"], (int)drow["year"]));
}

for（int i=0；i

如何在循环通过datatable时向数组中添加其他数据

更新1:

我同意@Reed提出的解决方案

// Create the array, specifying the total length 
car[] arrayOfCars = new car[dtable.Rows.Count]; 

for (int i = 0; i < dtable.Rows.Count; i++) 
{ 
    DataRow drow = dtable.Rows[i]; 
    // Assign each car to the specific index within the array (arrayOfCars[i]) 
    arrayOfCars[i] =  new car(drow["make"].ToString(), drow["year"].ToString()); 
} 

//创建数组，指定总长度
car[]arrayOfCars=新车[dtable.Rows.Count]；
for（int i=0；i

一旦创建了数组，就不能将元素添加到数组中。不要使用数组，而是使用

列表

。这将允许您调用.Add以添加元素

例如：

 // Create an List of car objects.      
 List<car> listOfCars = new List<car>()
 {
    new car("Ford",1992),
    new car("Fiat",1988),
    new car("Buick",1932),
    new car("Ford",1932),
    new car("Dodge",1999),
    new car("Honda",1977)
 };

如果必须具有数组，请在“添加到列表”后通过调用列表上的ToArray（）创建该数组：

// ... Add as above...
car[] arrayOfCars = listOfCars.ToArray(); // Creates an array from your list

---

编辑：

如果您只是尝试从DataTable分配和构造数组，并且在构造后不需要向其中添加元素，则可以使用数组，如下所示：

// Create the array, specifying the total length
car[] arrayOfCars = new car[dtable.Rows.Count];

for (int i = 0; i < dtable.Rows.Count; i++)
{
    DataRow drow = dtable.Rows[i];
    // Assign each car to the specific index within the array (arrayOfCars[i])
    arrayOfCars[i] =  new car(drow["make"].ToString(), drow["year"].ToString());
}

//创建数组，指定总长度
car[]arrayOfCars=新车[dtable.Rows.Count]；
for（int i=0；i

阵列无法就地调整大小

相反，您应该使用

列表

并调用

添加

，如下所示：

for (int i = 0; i < dtable.Rows.Count; i++)
{
    DataRow drow = dtable.Rows[i];
    arrayOfCars[] =  new car(drow["make"].ToString(), drow["year"].ToString());
}

 List<car> cars= new List<car>()
 {
    new car("Ford",1992),
    new car("Fiat",1988),
    new car("Buick",1932),
    new car("Ford",1932),
    new car("Dodge",1999),
    new car("Honda",1977)
 };  //C# 3 collection initializer

for (int i = 0; i < dtable.Rows.Count; i++)
{
    DataRow drow = dtable.Rows[i];
    cars.Add(new car((string)drow["make"], (int)drow["year"]));
}

List cars=新列表（）
{
新车（“福特”，1992年），
新车（“菲亚特”，1988年），
新车（“别克”，1932年），
新车（“福特”，1932年），
新车（“道奇”，1999年），
新车（“本田”，1977年）
};  //C#3集合初始值设定项
for（int i=0；i

如果您知道数组中总共有多少个元素，我建议您使用数组。否则，您最好按照Reed和SLaks的建议创建一个列表。

如上所述-使用

List

创建一个包含动态元素量的列表-使用方法

Add（Car item）

添加新实例。确保访问适当的MSDN站点：

---

顺便说一句：运算符

[]

在C#中不起作用，即使您创建了一个包含例如5个元素的数组并希望添加第一个元素。

一旦创建了数组，就不能添加新元素。但是，可以将其中的元素重新指定给新对象。如果需要新元素（以便数组增长），请使用（如前所述）Generic:

列表

。如果您想重新分配已经存在的元素，请使用以下内容（我还没有编译此内容，因此您可能需要进行更改：）

for（int i=0；i

您也可以使用LINQ来执行此操作

var fromTable = from row in dtable.Rows.OfType<DataRow>()
                let make = row["make"] as string
                let year = (int)row["year"]
                select new car(make, year);

car[] arrayOfCars = listOfCars.Concat(fromTable).ToArray();

var fromTable=dtable.Rows.OfType（）中的行
让make=行[“make”]作为字符串
让年份=（int）行[“年”]
选择新车（品牌、年份）；
car[]arrayOfCars=listOfCars.Concat（fromTable.ToArray（）；

。。。如果DataTable中有大量的行，并且您想要挤出一些性能，那么您可以这样做

var makeIndex = dtable.Columns["make"].Ordinal;
var yearIndex = dtable.Columns["year"].Ordinal;

var fromTable = from row in dtable.Rows.OfType<DataRow>()
                let items = row.ItemArray
                let make = items[makeIndex] as string
                let year = (int)items[yearIndex]
                select new car(make, year);

var makeIndex=dtable.Columns[“make”].Ordinal；
var yearIndex=dtable.Columns[“year”]。序数；
var fromTable=来自dtable.Rows.OfType（）中的行
让items=row.ItemArray
让make=items[makeIndex]作为字符串
let year=（int）项[yearIndex]
选择新车（品牌、年份）；

如果您有.NET 3.5，请使用Array.Resize（）

//创建汽车对象库。
car[]arrayOfCars=新车[]
{
新车（“福特”，1992年），
新车（“菲亚特”，1988年），
新车（“别克”，1932年），
新车（“福特”，1932年），
新车（“道奇”，1999年），
新车（“本田”，1977年）
};    
//调整数组大小。。。
var rowCount=dtable.Rows.Count；
变量偏移量=阵列长度；
调整数组大小（参考arrayOfCars，行数+偏移量）；
//从数据库填充新的（空）数组元素。。。
对于（int i=0；i

System.Array.Resize（…）

@Matthew Whited:Array.Resize基本上创建一个新数组，从旧数组复制所有项并返回新数组。它实际上不会调整旧数组的大小。列表封装了一个数组，如果需要，可以调整数组的大小，这样您就不必自己调整数组的大小（并跟踪实际的项数等）@Matthew，下一点是您不希望在循环的每次迭代中调整数组的大小。因此，要么（a）使用列表，要么（b）在循环之前创建适当的大小。可以获得调整大小的数组这一事实与此问题无关。（我想我应该注意到它需要数组的引用，这样你就可以替换内容了）。@dtb，你把我带到了那里。因此，数组的特定实例没有调整大小，但从引用/值的角度来看，它是。但是他似乎提前知道数组项的数量，所以为什么不初始化一个大小正确的数组呢？我相信这是因为他试图使用数组初始值设定项语法将项插入数组中。@dtb：是吗？这个问题不清楚他是完全从DataTable还是buildin构建数组

var fromTable = from row in dtable.Rows.OfType<DataRow>()
                let make = row["make"] as string
                let year = (int)row["year"]
                select new car(make, year);

car[] arrayOfCars = listOfCars.Concat(fromTable).ToArray();

var makeIndex = dtable.Columns["make"].Ordinal;
var yearIndex = dtable.Columns["year"].Ordinal;

var fromTable = from row in dtable.Rows.OfType<DataRow>()
                let items = row.ItemArray
                let make = items[makeIndex] as string
                let year = (int)items[yearIndex]
                select new car(make, year);

// Create an arary of car objects.      
     car[] arrayOfCars= new car[]
     {
        new car("Ford",1992),
        new car("Fiat",1988),
        new car("Buick",1932),
        new car("Ford",1932),
        new car("Dodge",1999),
        new car("Honda",1977)
     };    

// resize the array...
var rowCount = dtable.Rows.Count;
var offSet = arrayOfCars.Length;
Array.Resize<car>(ref arrayOfCars, rowCount + offSet);

// populate the new (empty) array elements from the database...
for (int i = 0; i < rowCount; i++)
{
    DataRow drow = dtable.Rows[i];
    arrayOfCars[i + offSet] =  
      new car(drow["make"].ToString(), drow["year"].ToString());
}