Cleanup readers

ArneD · ArneD · commit b19f7ad66c58 · 2017-02-20T20:36:50.000+01:00
diff --git a/src/UniqueFileRecordsComparer/UniqueFileRecordsComparer.App/SelectColumnsForm.cs b/src/UniqueFileRecordsComparer/UniqueFileRecordsComparer.App/SelectColumnsForm.cs
@@ -17,15 +17,13 @@ public SelectColumnsForm(ComparerArguments comparerArguments)
         {
             InitializeComponent();
 
-            using (var sourceReader = FileReaderFactory.CreateFromFileName(new FileInfoWrapper(new FileInfo(comparerArguments.SourceFilePath))))
-            {
-                _sourceRowCollection = sourceReader.Read();
-            }
+            var sourceReader =
+                FileReaderFactory.CreateFromFileName(new FileInfoWrapper(new FileInfo(comparerArguments.SourceFilePath)));
+            var targetReader =
+                FileReaderFactory.CreateFromFileName(new FileInfoWrapper(new FileInfo(comparerArguments.TargetFilePath)));
 
-            using (var targetReader = FileReaderFactory.CreateFromFileName(new FileInfoWrapper(new FileInfo(comparerArguments.TargetFilePath))))
-            {
-                _targetRowCollection = targetReader.Read();
-            }
+            _sourceRowCollection = sourceReader.Read();
+            _targetRowCollection = targetReader.Read();
 
             AddColumnsToCheckList(SourceColumnsCheckList, _sourceRowCollection);
             AddColumnsToCheckList(TargetColumnsCheckList, _targetRowCollection);
diff --git a/src/UniqueFileRecordsComparer/UniqueFileRecordsComparer.Core/Readers/CsvReader.cs b/src/UniqueFileRecordsComparer/UniqueFileRecordsComparer.Core/Readers/CsvReader.cs
@@ -1,17 +1,20 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.IO;
+using System.IO.Abstractions;
 using System.Linq;
 using CsvHelper;
+using CsvHelper.Configuration;
 
 namespace UniqueFileRecordsComparer.Core.Readers
 {
     public class CsvReader : IFileReader
     {
-        private readonly ICsvReader _reader;
+        private readonly FileInfoBase _fileInfo;
 
-        public CsvReader(ICsvReader reader)
+        public CsvReader(FileInfoBase fileInfo)
         {
-            _reader = reader;
+            _fileInfo = fileInfo;
         }
 
         public RowCollection Read()
@@ -22,32 +25,35 @@ public RowCollection Read()
 
         private IEnumerable<Row> ReadCsv()
         {
-            var rows = new List<Row>();
-            while (_reader.Read())
+            using (var reader = CreateCsvReader())
             {
-                var row = new Row();
-                for (var i = 0; i < _reader.CurrentRecord.Length; i++)
+                var rows = new List<Row>();
+                while (reader.Read())
                 {
-                    row.Add(new Column(_reader.FieldHeaders[i], _reader.CurrentRecord[i].Trim()));
+                    rows.Add(GetRow(reader));
                 }
-                rows.Add(row);
-            }
 
-            return rows;
+                return rows;
+            }
         }
 
-        public void Dispose()
+        private static Row GetRow(ICsvReader csvReader)
         {
-            Dispose(true);
-            GC.SuppressFinalize(this);
+            var row = new Row();
+            for (var i = 0; i < csvReader.CurrentRecord.Length; i++)
+            {
+                row.Add(new Column(csvReader.FieldHeaders[i], csvReader.CurrentRecord[i].Trim()));
+            }
+            return row;
         }
 
-        protected virtual void Dispose(bool disposing)
+        private CsvHelper.CsvReader CreateCsvReader()
         {
-            if (disposing)
+            return new CsvHelper.CsvReader(new StreamReader(_fileInfo.OpenRead()), new CsvConfiguration
             {
-                _reader?.Dispose();
-            }
+                HasHeaderRecord = true,
+                Delimiter = ";"
+            });
         }
     }
 }
diff --git a/src/UniqueFileRecordsComparer/UniqueFileRecordsComparer.Core/Readers/ExcelReader.cs b/src/UniqueFileRecordsComparer/UniqueFileRecordsComparer.Core/Readers/ExcelReader.cs
@@ -1,18 +1,19 @@
-﻿using System;
-using System.Collections.Generic;
+﻿using System.Collections.Generic;
 using System.Data;
+using System.IO;
+using System.IO.Abstractions;
 using System.Linq;
 using Excel;
 
 namespace UniqueFileRecordsComparer.Core.Readers
 {
     public class ExcelReader : IFileReader
     {
-        private readonly IExcelDataReader _excelDataReader;
+        private readonly FileInfoBase _fileInfo;
 
-        public ExcelReader(IExcelDataReader excelDataReader)
+        public ExcelReader(FileInfoBase fileInfo)
         {
-            _excelDataReader = excelDataReader;
+            _fileInfo = fileInfo;
         }
 
         public RowCollection Read()
@@ -22,44 +23,36 @@ public RowCollection Read()
 
         private IEnumerable<Row> ExtractDataSet()
         {
-            using (var result = _excelDataReader.AsDataSet())
+            using (var excelReader = ExcelReaderFactory.CreateOpenXmlReader(_fileInfo.Open(FileMode.Open, FileAccess.Read)))
             {
-                return GetRows(result);
+                excelReader.IsFirstRowAsColumnNames = true;
+                using (var result = excelReader.AsDataSet())
+                {
+                    return GetRows(result);
+                }
             }
         }
 
         private static IEnumerable<Row> GetRows(DataSet result)
         {
-            var rows = new List<Row>();
             var dataTable = result.Tables[0];
 
-            foreach (DataRow dataRow in dataTable.Rows)
-            {
-                var row = new Row();
-                var i = 0;
-                foreach (var item in dataRow.ItemArray)
-                {
-                    row.Add(new Column(dataTable.Columns[i].ColumnName, item.ToString().Trim()));
-                    i++;
-                }
-                rows.Add(row);
-            }
-
-            return rows;
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
+            return dataTable
+                    .Rows
+                    .Cast<DataRow>()
+                    .Select(GetRow);
         }
 
-        protected virtual void Dispose(bool disposing)
+        private static Row GetRow(DataRow dataRow)
         {
-            if (disposing)
+            var row = new Row();
+            var i = 0;
+            foreach (var item in dataRow.ItemArray)
             {
-                _excelDataReader?.Dispose();
+                row.Add(new Column(dataRow.Table.Columns[i].ColumnName, item.ToString().Trim()));
+                i++;
             }
+            return row;
         }
     }
 }
diff --git a/src/UniqueFileRecordsComparer/UniqueFileRecordsComparer.Core/Readers/FileReaderFactory.cs b/src/UniqueFileRecordsComparer/UniqueFileRecordsComparer.Core/Readers/FileReaderFactory.cs
@@ -1,8 +1,5 @@
 ﻿using System;
-using System.IO;
 using System.IO.Abstractions;
-using CsvHelper.Configuration;
-using Excel;
 
 namespace UniqueFileRecordsComparer.Core.Readers
 {
@@ -12,20 +9,12 @@ public static IFileReader CreateFromFileName(FileInfoBase fileInfoBase)
         {
             if (IsCsvFile(fileInfoBase.FullName))
             {
-                var reader = new CsvHelper.CsvReader(new StreamReader(fileInfoBase.OpenRead()), new CsvConfiguration
-                {
-                    HasHeaderRecord = true,
-                    Delimiter = ";"
-                });
-
-                return new CsvReader(reader);
+                return new CsvReader(fileInfoBase);
             }
 
             if (IsExcelFile(fileInfoBase.FullName))
             {
-                var excelReader = ExcelReaderFactory.CreateOpenXmlReader(fileInfoBase.Open(FileMode.Open, FileAccess.Read));
-                excelReader.IsFirstRowAsColumnNames = true;
-                return new ExcelReader(excelReader);
+                return new ExcelReader(fileInfoBase);
             }
 
             throw new InvalidOperationException();
diff --git a/src/UniqueFileRecordsComparer/UniqueFileRecordsComparer.Core/Readers/IFileReader.cs b/src/UniqueFileRecordsComparer/UniqueFileRecordsComparer.Core/Readers/IFileReader.cs
@@ -1,8 +1,6 @@
-using System;
-
 namespace UniqueFileRecordsComparer.Core.Readers
 {
-    public interface IFileReader : IDisposable
+    public interface IFileReader
     {
         RowCollection Read();
     }
diff --git a/src/UniqueFileRecordsComparer/tests/UniqueFileRecordsComparer.Core.IntegrationTests/CompareTwoFieldWithOneFieldTests.cs b/src/UniqueFileRecordsComparer/tests/UniqueFileRecordsComparer.Core.IntegrationTests/CompareTwoFieldWithOneFieldTests.cs
@@ -63,12 +63,9 @@ public void Test()
 
         private static RowCollection ReadRowCollection(string path)
         {
-            RowCollection csvRowCollection;
-            using (var reader = FileReaderFactory.CreateFromFileName(new FileInfoWrapper(new FileInfo(path))))
-            {
-                csvRowCollection = reader.Read();
-            }
-            return csvRowCollection;
+            var reader = FileReaderFactory.CreateFromFileName(new FileInfoWrapper(new FileInfo(path)));
+
+            return reader.Read();
         }
 
         private static void CheckFilesExist()

Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,20 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.IO;`
	`4`	`+using System.IO.Abstractions;`
`3`	`5`	`using System.Linq;`
`4`	`6`	`using CsvHelper;`
	`7`	`+using CsvHelper.Configuration;`
`5`	`8`
`6`	`9`	`namespace UniqueFileRecordsComparer.Core.Readers`
`7`	`10`	`{`
`8`	`11`	`public class CsvReader : IFileReader`
`9`	`12`	`{`
`10`		`- private readonly ICsvReader _reader;`
	`13`	`+ private readonly FileInfoBase _fileInfo;`
`11`	`14`
`12`		`- public CsvReader(ICsvReader reader)`
	`15`	`+ public CsvReader(FileInfoBase fileInfo)`
`13`	`16`	`{`
`14`		`- _reader = reader;`
	`17`	`+ _fileInfo = fileInfo;`
`15`	`18`	`}`
`16`	`19`
`17`	`20`	`public RowCollection Read()`
`@@ -22,32 +25,35 @@ public RowCollection Read()`
`22`	`25`
`23`	`26`	`private IEnumerable<Row> ReadCsv()`
`24`	`27`	`{`
`25`		`- var rows = new List<Row>();`
`26`		`- while (_reader.Read())`
	`28`	`+ using (var reader = CreateCsvReader())`
`27`	`29`	`{`
`28`		`- var row = new Row();`
`29`		`- for (var i = 0; i < _reader.CurrentRecord.Length; i++)`
	`30`	`+ var rows = new List<Row>();`
	`31`	`+ while (reader.Read())`
`30`	`32`	`{`
`31`		`- row.Add(new Column(_reader.FieldHeaders[i], _reader.CurrentRecord[i].Trim()));`
	`33`	`+ rows.Add(GetRow(reader));`
`32`	`34`	`}`
`33`		`- rows.Add(row);`
`34`		`- }`
`35`	`35`
`36`		`- return rows;`
	`36`	`+ return rows;`
	`37`	`+ }`
`37`	`38`	`}`
`38`	`39`
`39`		`- public void Dispose()`
	`40`	`+ private static Row GetRow(ICsvReader csvReader)`
`40`	`41`	`{`
`41`		`- Dispose(true);`
`42`		`- GC.SuppressFinalize(this);`
	`42`	`+ var row = new Row();`
	`43`	`+ for (var i = 0; i < csvReader.CurrentRecord.Length; i++)`
	`44`	`+ {`
	`45`	`+ row.Add(new Column(csvReader.FieldHeaders[i], csvReader.CurrentRecord[i].Trim()));`
	`46`	`+ }`
	`47`	`+ return row;`
`43`	`48`	`}`
`44`	`49`
`45`		`- protected virtual void Dispose(bool disposing)`
	`50`	`+ private CsvHelper.CsvReader CreateCsvReader()`
`46`	`51`	`{`
`47`		`- if (disposing)`
	`52`	`+ return new CsvHelper.CsvReader(new StreamReader(_fileInfo.OpenRead()), new CsvConfiguration`
`48`	`53`	`{`
`49`		`- _reader?.Dispose();`
`50`		`- }`
	`54`	`+ HasHeaderRecord = true,`
	`55`	`+ Delimiter = ";"`
	`56`	`+ });`
`51`	`57`	`}`
`52`	`58`	`}`
`53`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,19 @@`
`1`		`-using System;`
`2`		`-using System.Collections.Generic;`
	`1`	`+using System.Collections.Generic;`
`3`	`2`	`using System.Data;`
	`3`	`+using System.IO;`
	`4`	`+using System.IO.Abstractions;`
`4`	`5`	`using System.Linq;`
`5`	`6`	`using Excel;`
`6`	`7`
`7`	`8`	`namespace UniqueFileRecordsComparer.Core.Readers`
`8`	`9`	`{`
`9`	`10`	`public class ExcelReader : IFileReader`
`10`	`11`	`{`
`11`		`- private readonly IExcelDataReader _excelDataReader;`
	`12`	`+ private readonly FileInfoBase _fileInfo;`
`12`	`13`
`13`		`- public ExcelReader(IExcelDataReader excelDataReader)`
	`14`	`+ public ExcelReader(FileInfoBase fileInfo)`
`14`	`15`	`{`
`15`		`- _excelDataReader = excelDataReader;`
	`16`	`+ _fileInfo = fileInfo;`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`public RowCollection Read()`
`@@ -22,44 +23,36 @@ public RowCollection Read()`
`22`	`23`
`23`	`24`	`private IEnumerable<Row> ExtractDataSet()`
`24`	`25`	`{`
`25`		`- using (var result = _excelDataReader.AsDataSet())`
	`26`	`+ using (var excelReader = ExcelReaderFactory.CreateOpenXmlReader(_fileInfo.Open(FileMode.Open, FileAccess.Read)))`
`26`	`27`	`{`
`27`		`- return GetRows(result);`
	`28`	`+ excelReader.IsFirstRowAsColumnNames = true;`
	`29`	`+ using (var result = excelReader.AsDataSet())`
	`30`	`+ {`
	`31`	`+ return GetRows(result);`
	`32`	`+ }`
`28`	`33`	`}`
`29`	`34`	`}`
`30`	`35`
`31`	`36`	`private static IEnumerable<Row> GetRows(DataSet result)`
`32`	`37`	`{`
`33`		`- var rows = new List<Row>();`
`34`	`38`	`var dataTable = result.Tables[0];`
`35`	`39`
`36`		`- foreach (DataRow dataRow in dataTable.Rows)`
`37`		`- {`
`38`		`- var row = new Row();`
`39`		`- var i = 0;`
`40`		`- foreach (var item in dataRow.ItemArray)`
`41`		`- {`
`42`		`- row.Add(new Column(dataTable.Columns[i].ColumnName, item.ToString().Trim()));`
`43`		`- i++;`
`44`		`- }`
`45`		`- rows.Add(row);`
`46`		`- }`
`47`		`-`
`48`		`- return rows;`
`49`		`- }`
`50`		`-`
`51`		`- public void Dispose()`
`52`		`- {`
`53`		`- Dispose(true);`
`54`		`- GC.SuppressFinalize(this);`
	`40`	`+ return dataTable`
	`41`	`+ .Rows`
	`42`	`+ .Cast<DataRow>()`
	`43`	`+ .Select(GetRow);`
`55`	`44`	`}`
`56`	`45`
`57`		`- protected virtual void Dispose(bool disposing)`
	`46`	`+ private static Row GetRow(DataRow dataRow)`
`58`	`47`	`{`
`59`		`- if (disposing)`
	`48`	`+ var row = new Row();`
	`49`	`+ var i = 0;`
	`50`	`+ foreach (var item in dataRow.ItemArray)`
`60`	`51`	`{`
`61`		`- _excelDataReader?.Dispose();`
	`52`	`+ row.Add(new Column(dataRow.Table.Columns[i].ColumnName, item.ToString().Trim()));`
	`53`	`+ i++;`
`62`	`54`	`}`
	`55`	`+ return row;`
`63`	`56`	`}`
`64`	`57`	`}`
`65`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,5 @@`
`1`	`1`	`using System;`
`2`		`-using System.IO;`
`3`	`2`	`using System.IO.Abstractions;`
`4`		`-using CsvHelper.Configuration;`
`5`		`-using Excel;`
`6`	`3`
`7`	`4`	`namespace UniqueFileRecordsComparer.Core.Readers`
`8`	`5`	`{`
`@@ -12,20 +9,12 @@ public static IFileReader CreateFromFileName(FileInfoBase fileInfoBase)`
`12`	`9`	`{`
`13`	`10`	`if (IsCsvFile(fileInfoBase.FullName))`
`14`	`11`	`{`
`15`		`- var reader = new CsvHelper.CsvReader(new StreamReader(fileInfoBase.OpenRead()), new CsvConfiguration`
`16`		`- {`
`17`		`- HasHeaderRecord = true,`
`18`		`- Delimiter = ";"`
`19`		`- });`
`20`		`-`
`21`		`- return new CsvReader(reader);`
	`12`	`+ return new CsvReader(fileInfoBase);`
`22`	`13`	`}`
`23`	`14`
`24`	`15`	`if (IsExcelFile(fileInfoBase.FullName))`
`25`	`16`	`{`
`26`		`- var excelReader = ExcelReaderFactory.CreateOpenXmlReader(fileInfoBase.Open(FileMode.Open, FileAccess.Read));`
`27`		`- excelReader.IsFirstRowAsColumnNames = true;`
`28`		`- return new ExcelReader(excelReader);`
	`17`	`+ return new ExcelReader(fileInfoBase);`
`29`	`18`	`}`
`30`	`19`
`31`	`20`	`throw new InvalidOperationException();`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,6 @@`
`1`		`-using System;`
`2`		`-`
`3`	`1`	`namespace UniqueFileRecordsComparer.Core.Readers`
`4`	`2`	`{`
`5`		`- public interface IFileReader : IDisposable`
	`3`	`+ public interface IFileReader`
`6`	`4`	`{`
`7`	`5`	`RowCollection Read();`
`8`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,12 +63,9 @@ public void Test()`
`63`	`63`
`64`	`64`	`private static RowCollection ReadRowCollection(string path)`
`65`	`65`	`{`
`66`		`- RowCollection csvRowCollection;`
`67`		`- using (var reader = FileReaderFactory.CreateFromFileName(new FileInfoWrapper(new FileInfo(path))))`
`68`		`- {`
`69`		`- csvRowCollection = reader.Read();`
`70`		`- }`
`71`		`- return csvRowCollection;`
	`66`	`+ var reader = FileReaderFactory.CreateFromFileName(new FileInfoWrapper(new FileInfo(path)));`
	`67`	`+`
	`68`	`+ return reader.Read();`
`72`	`69`	`}`
`73`	`70`
`74`	`71`	`private static void CheckFilesExist()`