JohnH said:
Are you sick or something??
Totally!
You don't want to add an array as a new item in your ArrayList, you want to add the items in the array. Use the AddRange to add a range of objects.
mmmhhh.. I'm not sure this would be the case.. it really depends on how the data is to be represented internally. Using addrange will cause an arraylist to contain all the cells from a particular line, in one vertical column. If you repeatedly addrange then your file taht looks like this:
a,b,c
1,2,3
d,e,f
4,5,6
ends up in an arraylist of length 12 like this:
a
b
c
1
2
3
d
e
f
4
5
6
i.e. you lose the identity of the lines
Also, String and String() are the same, they are both data types, but objects of each will be different type objects.
I think you mean to say:
Dim x as String()
Dim x() as String
are the same (result)? In data type terms, a string object is different to an array object holding string types - both are objects, but they arent the same thing?
The reason both convensions exist is because of the different contexts you have to use one or the other. For instance when declaring an array with an initial number of elements you can't say 'Dim x As String(10)', you get an error 'array bound cannot appear in type specifiers'. You have to do 'Dim x(10) As String'. String is a type and String() is a type but String(10) is not a type.
I think this is one of those cases where VBs reuse of () to denote array as well as function makes the language a truly awful mess. In C#, java and other C-like variants, square brackets are used to denote array and array lengths:
string[] x = new string[10];
string x = new String("hello");
VB cannot make this distinction, which is a shame, because you then end up with somewhat inconsistent/messy declarations as:
Dim x as String() 'reads: x as string array
Dim x() as String 'reads: x is an array of string
Dim x(10) as String 'reads: x is an array size
11 of string
Dim x(0 to 10) as String 'reads: x is an array running from 0 to 10 of string
why
11? because 10 denotes the last accessible position..
All of them are just a wee bit yuck, they dont read right, and MS should have scrapped () for arrays and gone with something else.. the 0 to 10 syntax is probably the best, but if one is to use Type() to mean "array of type" then it shouldnt break as soon as you try to size it..
Dim x as String() = New String(10)
doesnt work either, because VB thinks youre trying to make a new String object, passing in 10 as a parameter to the constructor, and then assigning this to an array of string. I forget where it complains, but it cant be done..
However, if we tell VB is is an array with {} (normally reserved for preinitialization of an array) then it's quite happy..
Dim x as String() = New String(10){}
but you cannot (nor should you) shorten this to:
Dim x as New String(10){}
but do remember the kick in the backside: that the array declared in such a manner runs from 0 to 10, not 0 to 9 as in c/java, so you end up with an array of 11.
Your last question: shouldn't a single dimentional array of String()'s be a multidimentional array of Strings?
If you try to do this 'Dim x(10) As String()' you'll get an error saying 'array modifiers cannot be specified on both the variable and its type'. So there you have it, a case where type String() cannot be used.
a good question that further highlights the mess inherent..
You can indeed to multidim arrays in VB, through the rather ungainly syntax of :
Dim x()() as String = { New String(10){}, New String(10){}, New String(10){}}
We now have an array that can be accessed with:
x(N)(M) where N is a number from 0 to 2 inclusive, and M is a number from 0 to the size of the array at that location.. In this case we have made an array 3 x 11.. in c# the equivalent would be:
string[][] x = new string[3][11];
VB has a rectangular syntax to make up for this:
Dim x(2,10) As String
But you cant use this in any other form as VB only takes size initializers for top level arrays:
Dim x as String()() = New String(2)(
10) {}
-
Now, down to the problem..
Given that you want to combine 2 files into 1, i can kinda guess at the rules that make it happen, but I'd need to know if you are always going to find the same lines in each file, in the same order. If you are, then thats great.. But if the lines in the files may be in different orders, or file 1 will one day fail to contain 0001, Fred (but file 2 still does) then you'lll have a problem
The following code might make things easier for your task:
'this function takes a full path to a CSV file as a parameter and returns
'the contents of the file in a List object. The items in the list are organised
'in the same order as the lines are in the file
'each entry in the list is an array of strings denoting all the cells found
'on the line in the csv file
Private Function readCSVIntoTypedList(ByVal pathname As String) As System.Collections.Generic.List(Of String())
Dim reader As Microsoft.VisualBasic.FileIO.TextFieldParser
reader = My.Computer.FileSystem.OpenTextFieldParser(pathName)
reader.TextFieldType = Microsoft.VisualBasic.FileIO.FieldType.Delimited
reader.SetDelimiters(",")
Dim toReturn As New System.Collections.Generic.List(Of String())
Dim currentRow As String()
While Not reader.EndOfData
Try
currentRow = reader.ReadFields()
toReturn.Add(currentRow)
Catch ex As Microsoft.VisualBasic.FileIO.MalformedLineException
MsgBox("Line " & ex.Message & _
"is not valid and will be skipped.")
End Try
End While
Return toReturn
End Function
this function is crucial and helpful, as noted in the comment we will effectively end up with a list in memory that represents the file on disk. the list item 0 represents the first line.
So now we have the capability to read our files, we read them in:
Dim f1 as System.Collections.Generic.List(of String())
Dim f2 as System.Collections.Generic.List(of String())
Dim res as System.Collections.Generic.List(of String())
f1 = readCSVIntoList("C:\temp\file1.csv")
f2 = readCSVIntoList("C:\temp\file2.csv")
If f1.Count <> f2.Count Then
Throw New Exception("The files have different numbers of lines. This isnt supported")
'now we have both files in memory, lets make the result list, res, able to have the
'capacity to store all the items it needs to
res.Capacity = f1.Count
'skip over the lists
For i as Integer = 0 to f1.Count-1
'because both our lists are typed OF STRING() it means they can
'be treated as string arrays without casting
'f1.Item(0) and f1(0) both get the item at position 0
If f1(i).Length < 2 Or f2(i).Length < 2 Then
Throw New Exception("A line in one of the files doesnt have enough cells to perform this operation")
' the item in the list is an array and can be indexed like an array would
'this line says "set the item in the res list at position i to be a new string array
'f1(i) returns us a string array that has a 0 and a 1 index..
res(i) = New String(3){ f1(i)(0), f1(i)(1), f2(i)(1) }
Next i
'now lets skip over each item in our result list, jsut because we are bored :)
For Each x as String() in res
MessageBox.Show("Got an array of length " & x.Length & " in my res! :)")
'remember x is a string array
MessageBox.Show(String.Format("The items are: {0}, {1}, {2}", x))
Next x
Object lessons here are:
Throw arrays away as much as possible; theyre a pain in the backside because they are so inflexible. Easy to understand and been around since the beginning of time, but they make things such hard work sometimes!
Here, we preserve the structure of our file, rather than using AddRange which would destroy it. Note I could have used an arraylist to do all this, but ArrayList isnt typed.. it takes in objects and returns objects. You have to remember what type they are and cast to and from the types yourself.. major nuisance! Typed Lists on the other hand.. beautiful! every item behaves like an array.. and we can quickly and easily generate a 2D structure using them...
Note that we use lists because they automatically grow in a relatively resource cheap fashion, whereas an array is fixed, unless you redim preserve it all the time - doing that can potentially involve huge amounts of data copying around memory. Ugh.
