/// <summary>
/// Update header info, flush buffers and close streams. You should always call this method when you are done with a DBF file.
/// </summary>
public void Close()
{
//try to update the header if it has changed
//------------------------------------------
if (_header.IsDirty)
{
WriteHeader();
}
//try to update the footer if the file has been udpated
//------------------------------------------
if (_footerUpdateNeeded)
{
WriteFooter();
}
//Empty header...
//--------------------------------
_header = new DbfHeader(encoding);
_headerWritten = false;
//Clear the footer required flag
//------------------------------------------
_footerUpdateNeeded = false;
//reset current record index
//--------------------------------
_recordsReadCount = 0;
//Close streams...
//--------------------------------
if (_dbfFileWriter != null)
{
_dbfFileWriter.Flush();
_dbfFileWriter.Close();
}
if (_dbfFileReader != null)
{
_dbfFileReader.Close();
}
if (_dbfFile != null)
{
_dbfFile.Close();
_dbfFile.Dispose();
}
//set streams to null
//--------------------------------
_dbfFileReader = null;
_dbfFileWriter = null;
_dbfFile = null;
_fileName = "";
}
/// <summary>
///
/// </summary>
/// <param name="oHeader">Dbf Header will be locked once a record is created
/// since the record size is fixed and if the header was modified it would corrupt the DBF file.</param>
public DbfRecord(DbfHeader oHeader)
{
mHeader = oHeader;
mHeader.Locked = true;
//create a buffer to hold all record data. We will reuse this buffer to write all data to the file.
mData = new byte[mHeader.RecordLength];
mEmptyRecord = mHeader.EmptyDataRecord;
}
} // = Encoding.GetEncoding(866);
/// <summary>
///
/// </summary>
/// <param name="oHeader">Dbf Header will be locked once a record is created
/// since the record size is fixed and if the header was modified it would corrupt the DBF file.</param>
public DbfRecord(DbfHeader oHeader, int Codepage)
{
mHeader = oHeader;
mHeader.Locked = true;
//create a buffer to hold all record data. We will reuse this buffer to write all data to the file.
mData = new byte[mHeader.RecordLength];
mEmptyRecord = mHeader.EmptyDataRecord;
ASCIIEncoder = Encoding.GetEncoding(Codepage);
}
/// <summary>
///
/// </summary>
/// <param name="oHeader">Dbf Header will be locked once a record is created
/// since the record size is fixed and if the header was modified it would corrupt the DBF file.</param>
public DbfRecord(DbfHeader oHeader)
{
mHeader = oHeader;
mHeader.Locked = true;
//create a buffer to hold all record data. We will reuse this buffer to write all data to the file.
mData = new byte[mHeader.RecordLength];
mEmptyRecord = mHeader.EmptyDataRecord;
encoding = oHeader.encoding;
for (int i = 0; i < oHeader.mFields.Count; i++) mColNameToConIdx[oHeader.mFields[i].Name] = i;
}
/// <summary>
/// Open a DBF from a FileStream. This can be a file or an internet connection stream. Make sure that it is positioned at start of DBF file.
/// Reading a DBF over the internet we can not determine size of the file, so we support HasMore(), ReadNext() interface.
/// RecordCount information in header can not be trusted always, since some packages store 0 there.
/// </summary>
/// <param name="ofs"></param>
public void Open(Stream ofs)
{
if (mDbfFile != null)
{
Close();
}
mDbfFile = ofs;
mDbfFileReader = null;
mDbfFileWriter = null;
if (mDbfFile.CanRead)
{
mDbfFileReader = new BinaryReader(mDbfFile, Encoding.ASCII);
}
if (mDbfFile.CanWrite)
{
mDbfFileWriter = new BinaryWriter(mDbfFile, Encoding.ASCII);
}
//reset position
mRecordsReadCount = 0;
//assume header is not written
mHeaderWritten = false;
//read the header
if (ofs.CanRead)
{
//try to read the header...
try
{
mHeader.Read(mDbfFileReader);
mHeaderWritten = true;
}
catch (EndOfStreamException)
{
//could not read header, file is empty
mHeader = new DbfHeader();
mHeaderWritten = false;
}
}
if (mDbfFile != null)
{
mIsReadOnly = !mDbfFile.CanWrite;
mIsForwardOnly = !mDbfFile.CanSeek;
}
}
/// <summary>
/// Open a DBF from a FileStream. This can be a file or an internet connection stream. Make sure that it is positioned at start of DBF file.
/// Reading a DBF over the internet we can not determine size of the file, so we support HasMore(), ReadNext() interface.
/// RecordCount information in header can not be trusted always, since some packages store 0 there.
/// </summary>
/// <param name="ofs"></param>
public void Open(Stream ofs)
{
if (_dbfFile != null)
{
Close();
}
_dbfFile = ofs;
_dbfFileReader = null;
_dbfFileWriter = null;
if (_dbfFile.CanRead)
{
_dbfFileReader = new BinaryReader(_dbfFile, encoding);
}
if (_dbfFile.CanWrite)
{
_dbfFileWriter = new BinaryWriter(_dbfFile, encoding);
}
//reset position
_recordsReadCount = 0;
//assume header is not written
_headerWritten = false;
//read the header
if (ofs.CanRead)
{
//try to read the header...
try
{
_header.Read(_dbfFileReader);
_headerWritten = true;
}
catch (EndOfStreamException)
{
//could not read header, file is empty
_header = new DbfHeader(encoding);
_headerWritten = false;
}
}
if (_dbfFile != null)
{
_isReadOnly = !_dbfFile.CanWrite;
_isForwardOnly = !_dbfFile.CanSeek;
}
}
/// <summary>
/// Update header info, flush buffers and close streams. You should always call this method when you are done with a DBF file.
/// </summary>
public void Close()
{
//try to update the header if it has changed
//------------------------------------------
if (_header.IsDirty)
{
WriteHeader();
}
//Empty header...
//--------------------------------
_header = new DbfHeader(encoding);
_headerWritten = false;
//reset current record index
//--------------------------------
_recordsReadCount = 0;
//Close streams...
//--------------------------------
if (_dbfFileWriter != null)
{
_dbfFileWriter.Flush();
_dbfFileWriter.Close();
}
if (_dbfFileReader != null)
{
_dbfFileReader.Close();
}
if (_dbfFile != null)
{
_dbfFile.Close();
}
//set streams to null
//--------------------------------
_dbfFileReader = null;
_dbfFileWriter = null;
_dbfFile = null;
_fileName = "";
}
/// <summary>
///
/// </summary>
/// <param name="oHeader">Dbf Header will be locked once a record is created
/// since the record size is fixed and if the header was modified it would corrupt the DBF file.</param>
public DbfRecord(DbfHeader oHeader)
{
mHeader = oHeader;
mHeader.Locked = true;
//create a buffer to hold all record data. We will reuse this buffer to write all data to the file.
mData = new byte[mHeader.RecordLength];
mEmptyRecord = mHeader.EmptyDataRecord;
encoding = oHeader.encoding;
for (int i = 0; i < oHeader.mFields.Count; i++)
{
mColNameToConIdx[oHeader.mFields[i].Name] = i;
}
}
/// <summary>
///
/// </summary>
/// <param name="oHeader">Dbf Header will be locked once a record is created
/// since the record size is fixed and if the header was modified it would corrupt the DBF file.</param>
public DbfRecord(DbfHeader oHeader)
{
_header = oHeader;
_header.Locked = true;
//create a buffer to hold all record data. We will reuse this buffer to write all data to the file.
_data = new byte[_header.RecordLength];
_emptyRecord = _header.EmptyDataRecord;
encoding = oHeader.encoding;
for (int i = 0; i < oHeader._fields.Count; i++)
{
_colNameToIdx[oHeader._fields[i].Name] = i;
}
}
/// <summary>
/// Update header info, flush buffers and close streams. You should always call this method when you are done with a DBF file.
/// </summary>
public void Close()
{
//try to update the header if it has changed
//------------------------------------------
if(mHeader.IsDirty)
WriteHeader();
//Empty header...
//--------------------------------
mHeader = new DbfHeader();
mHeaderWritten = false;
//reset current record index
//--------------------------------
mRecordsReadCount = 0;
//Close streams...
//--------------------------------
if (mDbfFileWriter != null)
{
mDbfFileWriter.Flush();
mDbfFileWriter.Close();
}
if (mDbfFileReader != null)
mDbfFileReader.Close();
if (mDbfFile != null)
mDbfFile.Close();
//set streams to null
//--------------------------------
mDbfFileReader = null;
mDbfFileWriter = null;
mDbfFile = null;
mFileName = "";
}
protected static IEnumerable<DbfRecord> EnumRecords(DbfFile file, DbfHeader header)
{
var record = new DbfRecord(header);
while (file.ReadNext(record))
{
yield return record;
}
}
/// <summary>
/// Open a DBF from a FileStream. This can be a file or an internet connection stream. Make sure that it is positioned at start of DBF file.
/// Reading a DBF over the internet we can not determine size of the file, so we support HasMore(), ReadNext() interface.
/// RecordCount information in header can not be trusted always, since some packages store 0 there.
/// </summary>
/// <param name="ofs"></param>
public void Open(Stream ofs)
{
if (mDbfFile != null)
Close();
mDbfFile = ofs;
mDbfFileReader = null;
mDbfFileWriter = null;
if (mDbfFile.CanRead)
mDbfFileReader = new BinaryReader(mDbfFile, Encoding.ASCII);
if (mDbfFile.CanWrite)
mDbfFileWriter = new BinaryWriter(mDbfFile, Encoding.ASCII);
//reset position
mRecordsReadCount = 0;
//assume header is not written
mHeaderWritten = false;
//read the header
if(ofs.CanRead)
{
//try to read the header...
try
{
mHeader.Read(mDbfFileReader);
mHeaderWritten = true;
}
catch(EndOfStreamException)
{
//could not read header, file is empty
mHeader = new DbfHeader();
mHeaderWritten = false;
}
}
if (mDbfFile != null)
{
mIsReadOnly = !mDbfFile.CanWrite;
mIsForwardOnly = !mDbfFile.CanSeek;
}
}
public DbfFile(Encoding encoding)
{
this.encoding = encoding;
_header = new DbfHeader(encoding);
}
/// <summary>
///
/// </summary>
/// <param name="oHeader">Dbf Header will be locked once a record is created
/// since the record size is fixed and if the header was modified it would corrupt the DBF file.</param>
public DbfRecord(DbfHeader oHeader)
{
_header = oHeader;
_header.Locked = true;
//create a buffer to hold all record data. We will reuse this buffer to write all data to the file.
_data = new byte[_header.RecordLength];
_emptyRecord = _header.EmptyDataRecord;
encoding = oHeader.encoding;
for (int i = 0; i < oHeader._fields.Count; i++)
_colNameToIdx[oHeader._fields[i].Name] = i;
}
public DbfFile(Encoding encoding)
{
this.encoding = encoding;
_header = new DbfHeader(encoding);
}
/// <summary>
/// Open a DBF from a FileStream. This can be a file or an internet connection stream. Make sure that it is positioned at start of DBF file.
/// Reading a DBF over the internet we can not determine size of the file, so we support HasMore(), ReadNext() interface.
/// RecordCount information in header can not be trusted always, since some packages store 0 there.
/// </summary>
/// <param name="ofs"></param>
public void Open(Stream ofs)
{
if (_dbfFile != null)
Close();
_dbfFile = ofs;
_dbfFileReader = null;
_dbfFileWriter = null;
if (_dbfFile.CanRead)
_dbfFileReader = new BinaryReader(_dbfFile, encoding);
if (_dbfFile.CanWrite)
_dbfFileWriter = new BinaryWriter(_dbfFile, encoding);
//reset position
_recordsReadCount = 0;
//assume header is not written
_headerWritten = false;
//read the header
if (ofs.CanRead)
{
//try to read the header...
try
{
_header.Read(_dbfFileReader);
_headerWritten = true;
}
catch (EndOfStreamException)
{
//could not read header, file is empty
_header = new DbfHeader(encoding);
_headerWritten = false;
}
}
if (_dbfFile != null)
{
_isReadOnly = !_dbfFile.CanWrite;
_isForwardOnly = !_dbfFile.CanSeek;
}
}
/// <summary>
///
/// </summary>
/// <param name="oHeader">Dbf Header will be locked once a record is created
/// since the record size is fixed and if the header was modified it would corrupt the DBF file.</param>
public DbfRecord(DbfHeader oHeader)
{
mHeader = oHeader;
mHeader.Locked = true;
//create a buffer to hold all record data. We will reuse this buffer to write all data to the file.
mData = new byte[mHeader.RecordLength];
mEmptyRecord = mHeader.EmptyDataRecord;
}
/// <exception cref="Exception">Если файл не содержит необходимого столбца или имеет не верный формат</exception>
protected static int FindColumnOrThrow(DbfHeader header, String columnName,
DbfColumn.DbfColumnType? columnType = DbfColumn.DbfColumnType.Character,
int? maxLen = null)
{
var i = header.FindColumn(columnName);
if (i < 0) throw new Exception(ClassName + "Отсутсвует столбец " + columnName);
var column = header[i];
if (columnType.HasValue && column.ColumnType != columnType)
throw new Exception(String.Format(ClassName + "Тип столбца {0} должен быть {1}", columnName, columnType));
if (maxLen.HasValue && column.Length > maxLen)
throw new Exception(String.Format(ClassName + "Длина столбца {0} не должна превышать {1}", columnName, maxLen));
return i;
}
/// <summary>
/// Update header info, flush buffers and close streams. You should always call this method when you are done with a DBF file.
/// </summary>
public void Close()
{
//try to update the header if it has changed
//------------------------------------------
if (_header.IsDirty)
WriteHeader();
//Empty header...
//--------------------------------
_header = new DbfHeader(encoding);
_headerWritten = false;
//reset current record index
//--------------------------------
_recordsReadCount = 0;
//Close streams...
//--------------------------------
if (_dbfFileWriter != null)
{
_dbfFileWriter.Flush();
_dbfFileWriter.Close();
}
if (_dbfFileReader != null)
_dbfFileReader.Close();
if (_dbfFile != null)
{
_dbfFile.Close();
_dbfFile.Dispose();
}
//set streams to null
//--------------------------------
_dbfFileReader = null;
_dbfFileWriter = null;
_dbfFile = null;
_fileName = "";
}
/// <summary>
/// Update header info, flush buffers and close streams. You should always call this method when you are done with a DBF file.
/// </summary>
public void Close()
{
//try to update the header if it has changed
//------------------------------------------
if (_header.IsDirty)
WriteHeader();
//try to update the footer if the file has been udpated
//------------------------------------------
if (_footerUpdateNeeded)
WriteFooter();
//Empty header...
//--------------------------------
_header = new DbfHeader(encoding);
_headerWritten = false;
//Clear the footer required flag
//------------------------------------------
_footerUpdateNeeded = false;
//reset current record index
//--------------------------------
_recordsReadCount = 0;
//Close streams...
//--------------------------------
if (_dbfFileWriter != null)
{
_dbfFileWriter.Flush();
_dbfFileWriter.Close();
}
if (_dbfFileReader != null)
_dbfFileReader.Close();
if (_dbfFile != null)
_dbfFile.Close();
//set streams to null
//--------------------------------
_dbfFileReader = null;
_dbfFileWriter = null;
_dbfFile = null;
_fileName = "";
}
