Memory leak when reading from file

Question

I have this method to read from a .dbf file:

public DataTable ReadBulkDBF(string dbfFile, Dictionary<string, string> columnKeys, int maxRows, string dynamicValue, int nextId)
{
    long start = DateTime.Now.Ticks;
    DataTable dt = new DataTable();
    BinaryReader recReader;
    string number;
    string year;
    string month;
    string day;
    long lDate;
    long lTime;
    DataRow row;
    int fieldIndex;
    bool foundLastColumn = false;
    List<string> keys = new List<string>(columnKeys.Keys);
    List<string> values = new List<string>(columnKeys.Values);

    // For testing purposes
    int rowCount = 0;
    // If there isn't even a file, just return an empty DataTable
    if ((!File.Exists(dbfFile)))
    {
        return dt;
    }

    BinaryReader br = null;
    try
    {
        // Will allow shared open as long as the other application using it allows it too.
        // Read the header into a buffer
        br = new BinaryReader(File.Open(dbfFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
        byte[] buffer = br.ReadBytes(Marshal.SizeOf(typeof(DBFHeader)));

        // Marshall the header into a DBFHeader structure
        GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
        DBFHeader header = (DBFHeader)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(DBFHeader));
        handle.Free();

        // Read in all the field descriptors. Per the spec, 13 (0D) marks the end of the field descriptors
        ArrayList fields = new ArrayList();
        while ((13 != br.PeekChar()))
        {
            buffer = br.ReadBytes(Marshal.SizeOf(typeof(FieldDescriptor)));
            handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
            fields.Add((FieldDescriptor)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(FieldDescriptor)));
            handle.Free();
        }

        // Read in the first row of records, we need this to help determine column types below
        ((FileStream)br.BaseStream).Seek(header.headerLen + 1, SeekOrigin.Begin);
        buffer = br.ReadBytes(header.recordLen);
        recReader = new BinaryReader(new MemoryStream(buffer));

        // Create the columns in our new DataTable
        DataColumn col = null;

        dt.Columns.Add(new DataColumn("updateId", typeof(int)));
        if (!dbfFile.Contains("con_compania")) { dt.Columns.Add(new DataColumn("dynamic", typeof(string))); }
        dt.Columns.Add(new DataColumn("fechasync", typeof(DateTime)));

        foreach (FieldDescriptor field in fields)
        {
            // Adds columns to DataTable dt
        }

        // Skip past the end of the header. 
        ((FileStream)br.BaseStream).Seek(header.headerLen, SeekOrigin.Begin);

        // Read in all the records
        for (int counter = 0; counter < header.numRecords && dt.Rows.Count < maxRows; counter++)
        {
            // First we'll read the entire record into a buffer and then read each field from the buffer
            // This helps account for any extra space at the end of each record and probably performs better
            buffer = br.ReadBytes(header.recordLen);
            recReader = new BinaryReader(new MemoryStream(buffer));

            // All dbf field records begin with a deleted flag field. Deleted - 0x2A (asterisk) else 0x20 (space)
            if (recReader.ReadChar() == '*')
            {
                continue;
            }

            // Loop through each field in a record
            fieldIndex = 2;


            rowCount = dt.Rows.Count;
            row = dt.NewRow();

    foreach (FieldDescriptor field in fields)
            {
                switch (field.fieldType)
                {
                    // Casts field's value according to its type and saves it in the dt.

                }
                fieldIndex++;
            }
            // Looks for key-value combination in every row until 
            // it finds it to know where to start reading the new rows.
            if (!foundLastColumn && columnKeys.Keys.Count > 0)
            {
                foundLastColumn = true;

                int i = 3;

                if (dbfFile.Contains("con_compania")) { i = 2; }

                for (; i < keys.Count && foundLastColumn; i++)
                {
                    if (!row[keys[i]].ToString().Equals(values[i]))
                    {
                        foundLastColumn = false;
                    }
                }
            }
            else
            {
                dt.Rows.Add(row);
                nextId++;
            }

        }
    }
    catch (Exception e)
    {
        throw e;
    }
    finally
    {
        if (null != br)
        {
            br.Close();
            br.Dispose();
        }
    }

    long count = DateTime.Now.Ticks - start;

    return dt;
}

The problem is somewhere I am leaving some kind of reference to this, so I'm getting OOM.

The method is called with something like:

DataTable dt = new ParseDBF().ReadBulkDBF(...);
//Use dt
dt.Dispose();
dt = null;

If I only call Dispose() it keeps the reference and if I call null dt becomes null, but the reference to the ParseDBF object is still there somewhere.

Any idea where the leak might be? I have looked all over the internet for ideas and tried calling Dispose() and Close(), and setting as null everything I can think of after I use it and it keeps happening.

Answer 1

I notice that recreader may not be getting freed.

I would strongly suggest making use of using blocks within this code to ensure that IDisposable objects are cleaned when execution leaves the using scope.