C＃中string.Split（）与string.Substring（）的效率？

Question

I'm working on a project that involves taking large text files and parsing each line. The point is to parse the whole text file into cells, much like an Excel spreadsheet. Unfortunately, there are no delimiters for most of the files, so I need some sort of index-based method to manually create the cells, even if the column is blank.

Previously, lines were parsed by splitting on null, which worked well. However, new data has made this method unreliable due to its not including blank cells, so I had to make a new method of parsing lines, which uses Substring. The method takes in an array of integers indices and splits the strings on the given indices:

private string[] SetCols3(int[] fixedWidthValues, string line)
{
    {
    string[] cols = new string[fixedWidthValues.Length];

    int columnLength;
    int FWV;
    int FWV2;

    bool lastOfFWV;
    bool outOfBounds;

    for (int x = 0; x < fixedWidthValues.Length; x++)
    {
        FWV = fixedWidthValues[x];
        lastOfFWV = x + 1 >= fixedWidthValues.Length;
        outOfBounds = lastOfFWV ? true : fixedWidthValues[x + 1] >= line.Length;
        FWV2 = lastOfFWV || outOfBounds ? line.Length : fixedWidthValues[x + 1];
        columnLength = FWV2 - FWV;
        columnLength *= columnLength < 0 ? -1 : 1;

        if (FWV < line.Length)
        {
            cols[x] = line.Substring(FWV, columnLength).Trim();
        }
    }

    return cols;
}

Quick breakdown of the code: the integers and booleans are just to handle blank columns, lines that are shorter than normal, etc., and to make the code cleaner for other people to understand a little better (as opposed to one long, convoluted if statement).

My question: is there a way to make this more efficient? For some reason, this method takes significantly longer than the previous method. I understand it does more, so more time was expected. However, the difference is surprisingly huge. One iteration (with 15 indices) takes around 0.07 seconds (which is huge considering this method gets called several thousands time per file), compared to 0.00002 seconds on the high end for the method that splits on null. Is there something I can change in my code to noticeably increase its efficiency? I haven't been able to find anything particularly useful after hours of searching online.

Also, the number of indices/columns greatly affects the speed. For 15 columns, it takes around 0.07 seconds compared to 0.05 for 10 columns.

Answer 1

First,

outOfBounds = lastOfFWV ? true : fixedWidthValues[x + 1] >= line.Length;

could be changed to

outOfBounds = lastOfFWV || fixedWidthValues[x + 1] >= line.Length;

Next,

columnLength = FWV2 - FWV;
columnLength *= columnLength < 0 ? -1 : 1;

could be changed to

columnLength = Math.Abs(FWV2 - FWV);

And last,

if (FWV < line.Length)
{

could be moved to just after the FWV assignment at the top of the loop and changed to

if (FWV < line.Length)
    continue;

But, I don't think any of these changes would make a significant impact on speed. Possibly more impact would be gained by changing what's passed in. Instead of passing in the column starting positions and calculating the column widths for each line, which won't change, pass in the starting positions and column widths. This way there's no calculation involved.

But rather than guessing, it'd be best to profile the method to find the hot spot(s).

Answer 2

The issue was two stray .ToInt32() calls I accidentally included (I don't know why they were there). This particular method was a different method, one from my company, than the Convert.ToInt32(), and for some reason it was majorly inefficient when trying to convert numbers. For reference, the issues was on the following lines as follows:

FWV = fixedWidthValues[x].ToInt32();
...
FWV2 = lastOfFWV || outOfBounds ? line.Length : fixedWidthValues[x + 1].ToInt32();

Removing them increased the efficiency by 60 times...