public FileProvider(
TabularFileAdapterFactory fileAdapterFactory,
IMonitor monitor,
IReadOnlyCollection <string> attributeNames)
{
if (null == fileAdapterFactory)
{
throw new ArgumentNullException(nameof(fileAdapterFactory));
}
if (null == monitor)
{
throw new ArgumentNullException(nameof(monitor));
}
this.Monitor = monitor;
Type typeAttributeNames = typeof(AttributeNames);
IReadOnlyCollection <string> buffer =
typeAttributeNames.GetFields(BindingFlags.Public | BindingFlags.Static)
.Select(
(FieldInfo item) =>
(string)item.GetValue(null))
.ToArray();
this.ColumnNames =
buffer
.Union(attributeNames)
.Distinct()
.ToArray();
this.file = fileAdapterFactory.CreateFileAdapter(this.ColumnNames);
}
protected override void Dispose(bool disposing)
{
try
{
if (!disposing)
{
return;
}
if (this.file != null)
{
lock (this.thisLock)
{
if (this.file != null)
{
this.file.Dispose();
this.file = null;
}
}
}
}
finally
{
base.Dispose(true);
}
}
public FileProvider(string filePath)
:base(filePath)
{
Type typeAttributeNames = typeof(AttributeNames);
this.attributeNames =
typeAttributeNames.GetFields(BindingFlags.Public | BindingFlags.Static)
.Select(
(FieldInfo item) =>
(string)item.GetValue(null))
.ToArray();
this.file = new CommaDelimitedFileAdapter(this.FilePath, attributeNames);
}
public async Task TestInserting()
{
string fileName = CommaDelimitedFileUnitTest.ComposeFileName();
try
{
IReadOnlyCollection <string> columnNames =
Enumerable.Range(0, CommaDelimitedFileUnitTest.CountColumns)
.Select(
(int item) =>
item.ToString(CultureInfo.InvariantCulture))
.ToArray();
IList <string> keys = new List <string>(CommaDelimitedFileUnitTest.CountRows);
for
(
int indexIterations = 0;
indexIterations < CommaDelimitedFileUnitTest.CountInsertIterations;
indexIterations++
)
{
ITabularFileAdapter fileStore = null;
try
{
fileStore =
new AccessConnectivityEngineCommaDelimitedFileAdapterFactory(fileName)
.CreateFileAdapter(columnNames);
Assert.IsTrue(File.Exists(fileName));
for (int indexRows = 0; indexRows < CommaDelimitedFileUnitTest.CountRows; indexRows++)
{
Dictionary <string, string> columns =
columnNames
.ToDictionary(
(string item) =>
item,
(string item) =>
Guid.NewGuid().ToString());
IRow row = await fileStore.InsertRow(columns);
Assert.IsNotNull(row);
Assert.IsFalse(string.IsNullOrWhiteSpace(row.Key));
keys.Add(row.Key);
}
}
finally
{
if (fileStore != null)
{
fileStore.Dispose();
fileStore = null;
}
}
}
Assert.AreEqual(keys.LongCount(), keys.Distinct().LongCount());
Assert.AreEqual(keys.LongCount() + 1, File.ReadAllLines(fileName).Count());
}
finally
{
if (File.Exists(fileName))
{
File.Delete(fileName);
}
}
}
public async Task TestReplacing()
{
string fileName = CommaDelimitedFileUnitTest.ComposeFileName();
try
{
IReadOnlyCollection <string> columnNames =
Enumerable.Range(0, CommaDelimitedFileUnitTest.CountColumns)
.Select(
(int item) =>
item.ToString(CultureInfo.InvariantCulture))
.ToArray();
IRow rowOne;
ITabularFileAdapter fileStore = null;
string replacementValue;
try
{
fileStore =
new AccessConnectivityEngineCommaDelimitedFileAdapterFactory(fileName)
.CreateFileAdapter(columnNames);
Assert.IsTrue(File.Exists(fileName));
Dictionary <string, string> columnsWritten =
columnNames
.ToDictionary(
(string item) =>
item,
(string item) =>
Guid.NewGuid().ToString());
rowOne = await fileStore.InsertRow(columnsWritten);
Assert.IsNotNull(rowOne);
Assert.IsFalse(string.IsNullOrWhiteSpace(rowOne.Key));
IRow rowTwo = await fileStore.InsertRow(columnsWritten);
Assert.IsNotNull(rowTwo);
Assert.IsFalse(string.IsNullOrWhiteSpace(rowTwo.Key));
Assert.IsFalse(string.Equals(rowOne.Key, rowTwo.Key, StringComparison.OrdinalIgnoreCase));
string columnName = columnsWritten.Keys.Last();
replacementValue = Guid.NewGuid().ToString();
columnsWritten[columnName] = replacementValue;
IRow rowReplacment = new Row(rowOne.Key, columnsWritten);
await fileStore.ReplaceRow(rowReplacment);
}
finally
{
if (fileStore != null)
{
fileStore.Dispose();
fileStore = null;
}
}
IReadOnlyCollection <string> lines = File.ReadAllLines(fileName);
Assert.AreEqual(3, lines.LongCount());
Assert.AreEqual(
1,
lines
.Where(
(string item) =>
item.StartsWith(rowOne.Key, StringComparison.OrdinalIgnoreCase) &&
item.EndsWith(replacementValue, StringComparison.OrdinalIgnoreCase))
.LongCount());
}
finally
{
if (File.Exists(fileName))
{
File.Delete(fileName);
}
}
}
public async Task TestReading()
{
string fileName = CommaDelimitedFileUnitTest.ComposeFileName();
try
{
IReadOnlyCollection <string> columnNames =
Enumerable.Range(0, CommaDelimitedFileUnitTest.CountColumns)
.Select(
(int item) =>
item.ToString(CultureInfo.InvariantCulture))
.ToArray();
ITabularFileAdapter fileStore = null;
try
{
fileStore =
new AccessConnectivityEngineCommaDelimitedFileAdapterFactory(fileName)
.CreateFileAdapter(columnNames);
Assert.IsTrue(File.Exists(fileName));
Dictionary <string, string> columnsWritten =
columnNames
.ToDictionary(
(string item) =>
item,
(string item) =>
Guid.NewGuid().ToString());
IRow rowWritten = await fileStore.InsertRow(columnsWritten);
Assert.IsNotNull(rowWritten);
Assert.IsFalse(string.IsNullOrWhiteSpace(rowWritten.Key));
IRow rowRead = await fileStore.ReadRow(rowWritten.Key);
Assert.IsNotNull(rowRead.Columns);
Assert.AreEqual(CommaDelimitedFileUnitTest.CountColumns, rowRead.Columns.Count);
foreach (string columnName in columnsWritten.Keys)
{
Assert.IsTrue(
string.Equals(
columnsWritten[columnName],
rowRead.Columns[columnName],
StringComparison.OrdinalIgnoreCase));
}
}
finally
{
if (fileStore != null)
{
fileStore.Dispose();
fileStore = null;
}
}
}
finally
{
if (File.Exists(fileName))
{
File.Delete(fileName);
}
}
}
public async Task TestQuerying()
{
string fileName = CommaDelimitedFileUnitTest.ComposeFileName();
try
{
IReadOnlyCollection <string> columnNames =
Enumerable.Range(0, CommaDelimitedFileUnitTest.CountColumns)
.Select(
(int item) =>
item.ToString(CultureInfo.InvariantCulture))
.ToArray();
ITabularFileAdapter fileStore = null;
try
{
fileStore =
new AccessConnectivityEngineCommaDelimitedFileAdapterFactory(fileName)
.CreateFileAdapter(columnNames);
Assert.IsTrue(File.Exists(fileName));
Dictionary <string, string> columnsWritten =
columnNames
.ToDictionary(
(string item) =>
item,
(string item) =>
Guid.NewGuid().ToString());
IList <string> keys = new List <string>(CommaDelimitedFileUnitTest.CountRows);
for (int rowIndex = 0; rowIndex < CommaDelimitedFileUnitTest.CountRows; rowIndex++)
{
IRow rowWritten = await fileStore.InsertRow(columnsWritten);
Assert.IsNotNull(rowWritten);
Assert.IsFalse(string.IsNullOrWhiteSpace(rowWritten.Key));
Assert.IsFalse(
keys
.Any(
(string item) =>
string.Equals(item, rowWritten.Key, StringComparison.OrdinalIgnoreCase)));
keys.Add(rowWritten.Key);
}
IReadOnlyCollection <IRow> rowsRead = await fileStore.Query(columnsWritten);
Assert.IsNotNull(rowsRead);
Assert.AreEqual(3, rowsRead.Count);
Assert.IsTrue(
keys
.All(
(string keyItem) =>
rowsRead
.Any(
(IRow rowItem) =>
string.Equals(keyItem, rowItem.Key, StringComparison.OrdinalIgnoreCase))));
}
finally
{
if (fileStore != null)
{
fileStore.Dispose();
fileStore = null;
}
}
}
finally
{
if (File.Exists(fileName))
{
File.Delete(fileName);
}
}
}
protected override void Dispose(bool disposing)
{
try
{
if (!disposing)
{
return;
}
if (this.file != null)
{
lock (this.thisLock)
{
if (this.file != null)
{
this.file.Dispose();
this.file = null;
}
}
}
}
finally
{
base.Dispose(true);
}
}
