public void Open(string fileName, Mode mode)
{
if (mode == Mode.Read)
{
csvReader = new CSVReader(fileName);
}
else if (mode == Mode.Write)
{
csvWriter = new CSVWriter(fileName);
}
else
{
throw new Exception("Unknown file mode for " + fileName);
}
}
/// <summary>
/// Protected Dispose implementation that child implementations can override, allowing the base type to simply implement the IDisposable interface
/// and use a virtual method call to resolve the right Dispose logic
/// </summary>
/// <param name="disposeManaged">Whether to dispose managed objects</param>
protected virtual void Dispose(bool disposeManaged)
{
if (!_disposeCalled)
{
if (disposeManaged)
{
_reader?.Dispose();
_writer?.Dispose();
_writer = null;
_reader = null;
}
_disposeCalled = true;
}
}
/// <summary>
/// Opens the specified file in the specified mode, multiple calls are required if you wish to read and write to the same file.
/// Method behaviour is preserved for backcompat purposes.
/// </summary>
/// <param name="fileName">The file to open</param>
/// <param name="mode">The mode to open the file in (e.g. reading or writing)</param>
public void Open(string fileName, Mode mode)
{
// As the "Mode" enum is marked as [Flags], callers could use it in a bitfield fashion. But because this is production code, changing this behaviour to
// something like if ((mode & Mode.Read) == Mode.Read) { } if ((mode & Mode.Write) == Mode.Write) { } to allow for opening a reader and writer in one call would
// be a breaking change.
if (mode == Mode.Read)
{
_reader = new CSVReader(Separator, File.OpenRead(fileName));
}
else if (mode == Mode.Write)
{
_writer = new CSVWriter(Separator, File.OpenWrite(fileName));
}
else
{
throw new ArgumentException($"Unknown file mode {(int)mode} specified for " + fileName);
}
}
public CSVReaderWriter()
{
csvReader = new CSVReader();
csvWriter = new CSVWriter();
}
public CSVReaderWriter()
{
_CSVReader = new CSVReader();
_CSVWriter = new CSVWriter();
}