/// ///////////////////////////////////////////////////////////////////////
/// FieldMapper
///
/// <summary>
/// Constructor
/// </summary>
/// <param name="fileDescription"></param>
public FieldMapper_Reading(
DLFileDescription fileDescription,
string fileName,
bool writingFile)
: base(fileDescription, fileName, writingFile)
{
}
private void WriteData <T>(
IEnumerable <T> values,
string fileName,
TextWriter stream,
DLFileDescription fileDescription)
{
FieldMapper <T> fm = new FieldMapper <T>(fileDescription, fileName, true);
DLStream cs = new DLStream(null, stream, fileDescription.SeparatorChar);
List <string> row = new List <string>();
// If first line has to carry the field names, write the field names now.
if (fileDescription.FirstLineHasColumnNames)
{
fm.WriteNames(ref row);
cs.WriteRow(row, fileDescription.QuoteAllFields);
}
// -----
foreach (T obj in values)
{
// Convert obj to row
fm.WriteObject(obj, ref row);
cs.WriteRow(row, fileDescription.QuoteAllFields);
}
}
public void Write <T>(
IEnumerable <T> values,
TextWriter stream,
DLFileDescription fileDescription)
{
WriteData <T>(values, null, stream, fileDescription);
}
/// ///////////////////////////////////////////////////////////////////////
/// Read
///
/// <summary>
/// Reads the comma separated values from a stream or file.
/// Returns the data into an IEnumerable<T> that can be used for LINQ queries.
///
/// The stream or file will be closed after the last line has been processed.
/// Because the library implements deferred reading (using Yield Return), this may not happen
/// for a while.
/// </summary>
/// <typeparam name="T">
/// The records in the returned IEnumerable<T> will be of this type.
/// </typeparam>
/// <param name="stream">
/// The data will be read from this stream.
/// </param>
/// <param name="cultureInfo">
/// If the culture of the input data is different from the current culture,
/// pass the input culture here. For example, if you are in Australia and the data
/// is from the US, pass in "en-US".
/// </param>
/// <returns>
/// Values read from the stream or file.
/// </returns>
public IEnumerable <T> Read <T>(string fileName, DLFileDescription fileDescription) where T : new()
{
// Note that ReadData will not be called right away, but when the returned
// IEnumerable<T> actually gets accessed.
IEnumerable <T> ie = ReadData <T>(fileName, null, fileDescription);
return(ie);
}
/// ///////////////////////////////////////////////////////////////////////
/// Write
///
public void Write <T>(
IEnumerable <T> values,
string fileName,
DLFileDescription fileDescription)
{
using (StreamWriter sw = new StreamWriter(
fileName,
false,
fileDescription.TextEncoding))
{
WriteData <T>(values, fileName, sw, fileDescription);
}
}
/// ///////////////////////////////////////////////////////////////////////
/// FieldMapper
///
/// <summary>
/// Constructor
/// </summary>
/// <param name="fileDescription"></param>
public FieldMapper(DLFileDescription fileDescription, string fileName, bool writingFile)
{
if ((!fileDescription.FirstLineHasColumnNames) &&
(!fileDescription.EnforceDLColumnAttribute))
{
throw new DLColumnAttributeRequiredException();
}
// ---------
m_fileDescription = fileDescription;
m_fileName = fileName;
m_NameToInfo = new Dictionary <string, TypeFieldInfo>();
AnalyzeType(
typeof(T),
!fileDescription.FirstLineHasColumnNames,
writingFile && !fileDescription.FirstLineHasColumnNames);
}
/// ///////////////////////////////////////////////////////////////////////
/// ReadData
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="fileName">
/// Name of the file associated with the stream.
/// null if there is no such file.
/// Used solely when throwing an exception.
/// </param>
/// <param name="stream">
/// All data is read from this stream.
///
/// This is a StreamReader rather then a TextReader,
/// because we need to be able to seek back to the start of the
/// stream, and you can't do that with a TextReader (or s StringReader).
/// </param>
/// <param name="fileDescription"></param>
/// <returns></returns>
private IEnumerable <T> ReadData <T>(
string fileName,
StreamReader stream,
DLFileDescription fileDescription) where T : new()
{
// The constructor for FieldMapper_Reading will throw an exception if there is something
// wrong with type T. So invoke that constructor before you open the file, because if there
// is an exception, the file will not be closed.
FieldMapper_Reading <T> fm = new FieldMapper_Reading <T>(fileDescription, fileName, false);
// -------
// Each time the IEnumerable<T> that is returned from this method is
// accessed in a foreach, ReadData is called again (not the original Read overload!)
//
// So, open the file here, or rewind the stream.
bool readingFile = !string.IsNullOrEmpty(fileName);
if (readingFile)
{
stream = new StreamReader(
fileName,
fileDescription.TextEncoding,
fileDescription.DetectEncodingFromByteOrderMarks);
}
else
{
// Rewind the stream
if ((stream == null) || (!stream.BaseStream.CanSeek))
{
throw new BadStreamException();
}
stream.BaseStream.Seek(0, SeekOrigin.Begin);
}
// ----------
DLStream cs = new DLStream(stream, null, fileDescription.SeparatorChar);
List <DataRowItem> row = new List <DataRowItem>();
AggregatedException ae =
new AggregatedException(typeof(T).ToString(), fileName, fileDescription.MaximumNbrExceptions);
try
{
bool firstRow = true;
while (cs.ReadRow(ref row))
{
// Skip empty lines.
// Important. If there is a newline at the end of the last data line, the code
// thinks there is an empty line after that last data line.
if ((row.Count == 1) &&
((row[0].Value == null) ||
(string.IsNullOrEmpty(row[0].Value.Trim()))))
{
continue;
}
if (firstRow && fileDescription.FirstLineHasColumnNames)
{
fm.ReadNames(row);
}
else
{
T obj = default(T);
try
{
obj = fm.ReadObject(row, ae);
}
catch (AggregatedException ae2)
{
// Seeing that the AggregatedException was thrown, maximum number of exceptions
// must have been reached, so rethrow.
// Catch here, so you don't add an AggregatedException to an AggregatedException
throw ae2;
}
catch (Exception e)
{
// Store the exception in the AggregatedException ae.
// That way, if a file has many errors leading to exceptions,
// you get them all in one go, packaged in a single aggregated exception.
ae.AddException(e);
}
yield return(obj);
}
firstRow = false;
}
}
finally
{
if (readingFile)
{
stream.Close();
}
// If any exceptions were raised while reading the data from the file,
// they will have been stored in the AggregatedException ae.
// In that case, time to throw ae.
ae.ThrowIfExceptionsStored();
}
}
public IEnumerable <T> Read <T>(StreamReader stream, DLFileDescription fileDescription) where T : new()
{
return(ReadData <T>(null, stream, new DLFileDescription()));
}
