Develop Reference

What is the difference between these two list declarations?

var mylist1 = new List<float>(5);
var mylist2 = new List<float>(new float[5]);
mylist1 gets 5 as a capacity. mylist2 gets 5 too. What is the difference between these two and which one should I use?

The first declaration creates a list with an underlying array with a size of 5.
The second declaration copies data from the passed array to the underlying array in the list.
So the second declaration needs to:
Create an empty array
Copy the values in that array to another array
Since it's also harder to read (what's the point of passing an empty array to a list constructor?), there really isn't any reason at all to use the second instead of the first.
The reason the overload is there is to allow you to prefill the list with values from another array or enumerable. For example:
var list = new List<int>(Enumerable.Range(1, 100));
(though of course, even then you'd usually use Enumerable.Range(1, 100).ToList() instead :))

The first create a List having capacity 5, but empty.i.e, if you access myList1[3] you get an error.
The second create a List of float containing already 5 elements. each element will have value 0.0, i.e the default value for a float

Redim Statement in VB and C#

What will be the C# equivalent of the following ReDim a(0 To i, 0 To 1) ?
I am trying to implement using it by Array.resize ... but it's not working.

Since you aren't using Preserve, this is just:
a = new SomeType[i,1];
More generally Array.Resize (which is akin to ReDim Preserve) only works on vectors (1-dimensional 0-based arrays); there is not an overload for multi-dimensional arrays. You can, however, simply create a new array and then copy the data from the old array to the new array in a loop. However, frankly if you are routinely resizing arrays, then something might be wrong in your code - maybe consider some kind of nested list; or since your second direction is always 0-1, either two separate arrays/lists, or a single array/list of a type with two members.

How to Convert this snippet from VB6 To C#

This is the VB6 Code I have
Dim aBcls() As String
ReDim aBcls(0 To iCount, 0 To 1)
For i = 0 To iCount
aBcls(i, 0) = Pick.Extract(sOutput, 1, i + 1)
aBcls(i, 1) = Pick.Extract(sOutput, 2, i + 1)
Next i
I am not able to understand how to convert it to C# Code.
Can someone please guide me on this?

The intent of the VB6 code is to have an array that contains two strings, aka a multi-dimensional array of strings. You can do this either exactly or using a single dimensional array of objects that have two strings (class, struct or tupple).
I would tend towards using using a 1-dimensional array of a class of objects with two strings, unless that conflicts with usage elsewhere.
Note that it uses redim, which you can't do with MD arrays, but from your snippet that was unnecessary. If it is neccesary, you might want to see if you can use a list instead.
Also note that VB6 used ByRef by default, so sOutput could conceivably be changed by pick.extract.

How do I expand an array in C# without using the new keyword

I have a char array in C#.
var arr = new char[3] { 'a','b','c' };
How do I add spaces to the end of it without creating a new array?
result: arr = { 'a', 'b', 'c', ' ', ' ', ' ' };
This might sound similar to VB.NET's ReDim. But I'm not sure that is what I want either.
I want to preserve the elements inside of it and not instantiate a new array behind the scenes.
Is this only possible with Generic Collections and ArrayList?
Thanks

No, this is not possible using an array, generic or otherwise.. AFAIK, there is no way to dynamically resize an array. Use a List instead.
As Martin pointed out in the comments, even the List class uses an array in its internal implementation. If you want to truly be able to dynamically resize a data structure without reinitializing it, you must implement your own version of a linked list.
System.Collections.Generic contains a class called LinkedList that represents a doubly-linked list (meaning that each node has a reference to both the next and the previous node), but I'm not sure if its internal implementation uses an array..

Unfortunately, arrays are pre-fixed by design. This is important because it will reserve the necessary amout of memory at the heap.
So, to answer your requirement about not creating a new one: it won't be possible.
There is, however, a work-around. Look the following method:
Array.Resize(ref myArr, myArr.Length + 5);
It works as described at the source:
This method allocates a new array with the specified size, copies
elements from the old array to the new one, and then replaces the old
array with the new one.
If array is null, this method creates a new array with the specified
size.
If newSize is greater than the Length of the old array, a new array is
allocated and all the elements are copied from the old array to the
new one. If newSize is less than the Length of the old array, a new
array is allocated and elements are copied from the old array to the
new one until the new one is filled; the rest of the elements in the
old array are ignored. If newSize is equal to the Length of the old
array, this method does nothing.
This method is an O(n) operation, where n is newSize.
This means that myArr will be updated to reference the new array. However, if there is another reference to the original array, this won't be updated (it will keep referencing the older version).
Source: MSDN

Array of an unknown length in C#

I've just started learning C# and in the introduction to arrays they showed how to establish a variable as an array but is seems that one must specify the length of the array at assignment, so what if I don't know the length of the array?

Arrays must be assigned a length. To allow for any number of elements, use the List class.
For example:
List<int> myInts = new List<int>();
myInts.Add(5);
myInts.Add(10);
myInts.Add(11);
myInts.Count // = 3

Use List<> to build up an 'array' of unknown length.
Use List<>.ToArray() to return a real array, and not a List.
var list = new List<int>();
list.Add(1);
list.Add(2);
list.Add(3);
var array = list.ToArray();

A little background information:
As said, if you want to have a dynamic collection of things, use a List<T>. Internally, a List uses an array for storage too. That array has a fixed size just like any other array. Once an array is declared as having a size, it doesn't change. When you add an item to a List, it's added to the array. Initially, the List starts out with an array that I believe has a length of 16. When you try to add the 17th item to the List, what happens is that a new array is allocated, that's (I think) twice the size of the old one, so 32 items. Then the content of the old array is copied into the new array. So while a List may appear dynamic to the outside observer, internally it has to comply to the rules as well.
And as you might have guessed, the copying and allocation of the arrays isn't free so one should aim to have as few of those as possible and to do that you can specify (in the constructor of List) an initial size of the array, which in a perfect scenario is just big enough to hold everything you want. However, this is micro-optimization and it's unlikely it will ever matter to you, but it's always nice to know what you're actually doing.

You can create an array with the size set to a variable, i.e.
int size = 50;
string[] words = new string[size]; // contains 50 strings
However, that size can't change later on, if you decide you need 100 words. If you need the size to be really dynamic, you'll need to use a different sort of data structure. Try List.

Use an ArrayList if in .NET 1.x, or a List<yourtype> if in .NET 2.0 or 3.x.
Search for them in System.Collections and System.Collections.Generics.

You might also want to look into Dictionarys if your data is unique, This will give you two columns to work with.
User name , Total bill
it gives you a lot of built in tools to search and update just the value.

var yummy = new List<string>();
while(person.FeelsHappy()) {
yummy.Add(person.GetNewFavoriteFood());
}
Console.WriteLine("Sweet! I have a list of size {0}.", list.Count);
Console.WriteLine("I didn't even need to know how big to make it " +
"until I finished making it!");

try a generic list instead of array

In a nutshell, please use Collections and Generics.
It's a must for any C# developer, it's worth spending time to learn :)

As detailed above, the generic List<> is the best way of doing it.
If you're stuck in .NET 1.*, then you will have to use the ArrayList class instead. This does not have compile-time type checking and you also have to add casting - messy.
Successive versions have also implemented various variations - including thread safe variants.

If you really need to use an array instead of a list, then you can create an array whose size is calculated at run time like so...
e.g i want a two dimensional array of size n by n. n will be gotten at run time from the user
int n = 0;
bool isInteger = int.TryParse(Console.ReadLine(), out n);
var x = new int[n,n];