Array Over size Problem

Zeb Rehman

Hello everybody,
When i run the following code it give me the error which is also given below. I think there is problem of Array size. Can somebody please tell me how can i remove this error. My main goal is to save the value from database to array.
Thanks

using System;
using System.Data.OleDb;
using System.IO;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace _2
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
try
{
int count = 0;
string[] name = null;
string[] address = null;
string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;data source=D:\\ptcl.accdb";

OleDbConnection conn = new OleDbConnection(connectionString);

string sql = "SELECT * FROM 51";

OleDbCommand cmd = new OleDbCommand(sql, conn);
{
conn.Open();
OleDbCommand com = new OleDbCommand(sql, conn);
OleDbDataReader dr = com.ExecuteReader();
while (dr.Read())
{
name[count] = dr.GetString(1).ToString();
//textBox1.Text = count.ToString() ;
//count++;
}
conn.Close();
}
}

catch (Exception ex)
{ MessageBox.Show(ex.ToString());}
}
}
}

5 Replies

Know the answer? Post it — somebody with the same question will find it here.

theLizard14y ago
Accepted answer
I think you are missing the point, you said that in C# you need to know in advance what the size of an array is before you declare it, clearly that is not the case.

Whether or not it is efficient is another argument.

Whilst it's true that you can resize an Array, it's inefficient compared to the way that the List class deals with this problem.

As theLizard's code stands, he's resizing the array after each element is added.

This is true...

This means that a new array has to be created of the appropriate size and the elements of the previous array copied over to it. There is also more pressure on the garbage collector because the old arrays all have to be destroyed and their memory reclaimed.

The List class uses a T[] internally to store its elements. When the first element is added, this array is initialized to a capacity of 4, when the 5th element is added, the internal array is resized to a capacity of 8 and so on with the previous capacity being doubled as needed.

Unless I misunderstand this is no different to Array.Resize, it does the same thing, the old array is copied to a new one of the increased size.

This means that there are far fewer resizing operations and less pressure on the garbage collector. The trade-off, of course, is that List uses more memory than resizing the array 'manually' but this is unimportant in most small or medium sized applications.

There is no reason why you cannot declare the array with more than 0 elements, you could intitialize the array with the same number of elements as List does and increase the size by the number of elements you want but this means better management of your arrays.

I think, but not certain, that List and Arrays in C# are / use std::vector, also, learning to 'manually' do things is not a bad thing, there are many advantages for doing so.
Vulpes14y ago
Without wishing to 'split hairs' what I said isn't really wrong.

You do need to know in advance what the size of an array is before you declare it, even if the size is only 1.

Also, as Zeb is clearly a novice programmer, I'm hardly going to suggest that he should be managing the resizing of his own arrays when List is available to do it for him. If I'd said that, then Sam for one would have torn me to pieces ;)

You're right, of course, that List does use Array.Resize internally when the capacity needs to be doubled.

Also, as the CLR is written in VC++ and single dimensional, zero based arrays are referred to as SZarrays or vectors in books about its inner workings, you're probably right that they are represented by instances of std::vector internally.
Vulpes14y ago
Whilst it's true that you can resize an Array, it's inefficient compared to the way that the List class deals with this problem.

As theLizard's code stands, he's resizing the array after each element is added. This means that a new array has to be created of the appropriate size and the elements of the previous array copied over to it. There is also more pressure on the garbage collector because the old arrays all have to be destroyed and their memory reclaimed.

The List class uses a T[] internally to store its elements. When the first element is added, this array is initialized to a capacity of 4, when the 5th element is added, the internal array is resized to a capacity of 8 and so on with the previous capacity being doubled as needed. This means that there are far fewer resizing operations and less pressure on the garbage collector. The trade-off, of course, is that List uses more memory than resizing the array 'manually' but this is unimportant in most small or medium sized applications.
theLizard14y ago
However, unless you know in advance how many records there are in the database, you can't initialize the array because arrays in C# have to be a fixed size.

Not true.. you can resize an array
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
class Class1
{
public string s;
public int j;
}
}
//declare an array of Class1 with 0 elements
Class1[] c = new Class1[0];

Array.Resize(ref c, c.Length +1); //add 1 element to the array
c[c.Length -1] = new Class1();

//setting values to new array element
c[c.Length -1].j = 123;
c[c.Length -1].s = "New Element";
//accessing array element added
int number = c[c.Length -1].j;
string a = c[c.Length -1].s;

std::vector in C++
Vulpes14y ago
The problem is that the name array hasn't been initialized.

However, unless you know in advance how many records there are in the database, you can't initialize the array because arrays in C# have to be a fixed size.

What I'd do instead is to use a List whose size can increase dynamically as new elements are added. You can always change this to an array afterwards by calling
its ToArray() method.

You also seem to have a duplicated line here.

So, I'd suggest:

private void button1_Click(object sender, EventArgs e)
{
try
{
int count = 0;
List name = new List();
List address = new List();
string connectionString = "Provider=Microsoft.Jet.OLEDB.4.0;data source=D:\\ptcl.accdb";

OleDbConnection conn = new OleDbConnection(connectionString);

string sql = "SELECT * FROM 51";
OleDbCommand com = new OleDbCommand(sql, conn);
conn.Open();
OleDbDataReader dr = com.ExecuteReader();
while (dr.Read())
{
name.Add(dr.GetString(1));
//textBox1.Text = count.ToString() ;
//count++;
}
conn.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}