From 5a29ff205b5c2630ef1a66e42ad721436747571e Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Sat, 4 Aug 2018 22:40:10 -0500
Subject: [PATCH 01/17] Add visual studio test runner.

---
 src/FlatFile.Tests/FlatFile.Tests.csproj | 9 +++++++++
 src/FlatFile.Tests/packages.config       | 1 +
 2 files changed, 10 insertions(+)

diff --git a/src/FlatFile.Tests/FlatFile.Tests.csproj b/src/FlatFile.Tests/FlatFile.Tests.csproj
index 57f98f9..3d02e08 100644
--- a/src/FlatFile.Tests/FlatFile.Tests.csproj
+++ b/src/FlatFile.Tests/FlatFile.Tests.csproj
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props" Condition="Exists('..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props')" />
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -13,6 +14,8 @@
     <FileAlignment>512</FileAlignment>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -138,6 +141,12 @@
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props'))" />
+  </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/src/FlatFile.Tests/packages.config b/src/FlatFile.Tests/packages.config
index 0f982a6..1357199 100644
--- a/src/FlatFile.Tests/packages.config
+++ b/src/FlatFile.Tests/packages.config
@@ -11,4 +11,5 @@
   <package id="xunit.extensibility.core" version="2.1.0" targetFramework="net45" />
   <package id="xunit.extensibility.execution" version="2.1.0" targetFramework="net45" />
   <package id="xunit.runner.console" version="2.1.0" targetFramework="net45" />
+  <package id="xunit.runner.visualstudio" version="2.1.0" targetFramework="net45" />
 </packages>
\ No newline at end of file

From 0ebf171d05d0079b4704a0080fbe237119871727 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Sat, 4 Aug 2018 22:49:17 -0500
Subject: [PATCH 02/17] Add support for customization of master-detail record
 handling.

---
 appveyor.yml                                  |   2 +-
 .../FlatFile.FixedLength.csproj               |   2 +
 .../IMasterDetailTracker.cs                   |  10 +
 .../FixedLengthFileEngineFactory.cs           |   5 +-
 .../FixedLengthFileMultiEngine.cs             |  44 +---
 .../Implementation/MasterDetailTracker.cs     |  81 ++++++++
 .../FixedLengthMasterDetailCustomTests.cs     | 191 ++++++++++++++++++
 .../FixedLengthMasterDetailTests.cs           |   3 +-
 .../FixedLengthMultiEngineTests.cs            |   3 +-
 src/FlatFile.Tests/FlatFile.Tests.csproj      |   1 +
 10 files changed, 300 insertions(+), 42 deletions(-)
 create mode 100644 src/FlatFile.FixedLength/IMasterDetailTracker.cs
 create mode 100644 src/FlatFile.FixedLength/Implementation/MasterDetailTracker.cs
 create mode 100644 src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailCustomTests.cs

diff --git a/appveyor.yml b/appveyor.yml
index 2eb7710..24774ec 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,5 +1,5 @@
 - 
-  version: 0.2.{build}
+  version: 0.3.{build}
 
   environment:
     BuildEnvironment: appveyor
diff --git a/src/FlatFile.FixedLength/FlatFile.FixedLength.csproj b/src/FlatFile.FixedLength/FlatFile.FixedLength.csproj
index f0090b9..bbfc578 100644
--- a/src/FlatFile.FixedLength/FlatFile.FixedLength.csproj
+++ b/src/FlatFile.FixedLength/FlatFile.FixedLength.csproj
@@ -95,6 +95,7 @@
   <ItemGroup>
     <Compile Include="FixedFieldSettings.cs" />
     <Compile Include="IDetailRecord.cs" />
+    <Compile Include="IMasterDetailTracker.cs" />
     <Compile Include="IMasterRecord.cs" />
     <Compile Include="Implementation\FixedLengthFileMultiEngine.cs" />
     <Compile Include="IFixedFieldSettingsConstructor.cs" />
@@ -112,6 +113,7 @@
     <Compile Include="Implementation\FixedLengthLineBuilderFactory.cs" />
     <Compile Include="Implementation\FixedLengthLineParser.cs" />
     <Compile Include="Implementation\FixedLengthLineParserFactory.cs" />
+    <Compile Include="Implementation\MasterDetailTracker.cs" />
     <Compile Include="Padding.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
diff --git a/src/FlatFile.FixedLength/IMasterDetailTracker.cs b/src/FlatFile.FixedLength/IMasterDetailTracker.cs
new file mode 100644
index 0000000..5ab96d0
--- /dev/null
+++ b/src/FlatFile.FixedLength/IMasterDetailTracker.cs
@@ -0,0 +1,10 @@
+namespace FlatFile.FixedLength
+{
+    /// <summary>
+    /// Determines how master-detail record relationships are handled.
+    /// </summary>
+    public interface IMasterDetailTracker
+    {
+        void HandleMasterDetail(object entry, out bool isDetailRecord);
+    }
+}
\ No newline at end of file
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
index 132ee69..96257fa 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
@@ -58,17 +58,20 @@ public IFlatFileEngine GetEngine(
         /// <param name="layoutDescriptors">The layout descriptors.</param>
         /// <param name="typeSelectorFunc">The type selector function.</param>
         /// <param name="handleEntryReadError">The handle entry read error func.</param>
+        /// <param name="masterDetailTracker">Determines how master-detail record relationships are handled.</param>
         /// <returns>IFlatFileMultiEngine.</returns>
         public IFlatFileMultiEngine GetEngine(
             IEnumerable<ILayoutDescriptor<IFixedFieldSettingsContainer>> layoutDescriptors,
             Func<string, int, Type> typeSelectorFunc,
-            Func<string, Exception, bool> handleEntryReadError = null)
+            Func<string, Exception, bool> handleEntryReadError = null,
+            IMasterDetailTracker masterDetailTracker = null)
         {
             return new FixedLengthFileMultiEngine(
                 layoutDescriptors,
                 typeSelectorFunc,
                 new FixedLengthLineBuilderFactory(),
                 lineParserFactory,
+                masterDetailTracker ?? new MasterDetailTracker(),
                 handleEntryReadError);
         }
     }
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
index 9226d09..2f33983 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
@@ -40,9 +40,9 @@ public class FixedLengthFileMultiEngine : FlatFileEngine<IFixedFieldSettingsCont
         /// </summary>
         readonly Dictionary<Type, ArrayList> results;
         /// <summary>
-        /// The last record parsed that implements <see cref="IMasterRecord"/>
+        /// Determines how master-detail record relationships are handled.
         /// </summary>
-        IMasterRecord lastMasterRecord;
+        readonly IMasterDetailTracker masterDetailTracker;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="FixedLengthFileMultiEngine"/> class.
@@ -52,12 +52,14 @@ public class FixedLengthFileMultiEngine : FlatFileEngine<IFixedFieldSettingsCont
         /// <param name="lineBuilderFactory">The line builder factory.</param>
         /// <param name="lineParserFactory">The line parser factory.</param>
         /// <param name="handleEntryReadError">The handle entry read error.</param>
+        /// <param name="masterDetailTracker">Determines how master-detail record relationships are handled.</param>
         /// <exception cref="System.ArgumentNullException">typeSelectorFunc</exception>
         internal FixedLengthFileMultiEngine(
             IEnumerable<ILayoutDescriptor<IFixedFieldSettingsContainer>> layoutDescriptors,
             Func<string, int, Type> typeSelectorFunc,
             IFixedLengthLineBuilderFactory lineBuilderFactory,
             IFixedLengthLineParserFactory lineParserFactory,
+            IMasterDetailTracker masterDetailTracker,
             Func<string, Exception, bool> handleEntryReadError = null)
         {
             if (typeSelectorFunc == null) throw new ArgumentNullException("typeSelectorFunc");
@@ -70,6 +72,7 @@ internal FixedLengthFileMultiEngine(
             this.typeSelectorFunc = typeSelectorFunc;
             this.lineBuilderFactory = lineBuilderFactory;
             this.lineParserFactory = lineParserFactory;
+            this.masterDetailTracker = masterDetailTracker;
             this.handleEntryReadError = handleEntryReadError;
         }
 
@@ -202,47 +205,12 @@ private void ReadInternal(StreamReader reader)
                 if (ignoreEntry) continue;
 
                 bool isDetailRecord;
-                HandleMasterDetail(entry, out isDetailRecord);
+                masterDetailTracker.HandleMasterDetail(entry, out isDetailRecord);
 
                 if (isDetailRecord) continue;
 
                 results[type].Add(entry);
             }
         }
-
-
-        /// <summary>
-        /// Handles any master/detail relationships for this <paramref name="entry"/>.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="entry">The entry.</param>
-        /// <param name="isDetailRecord">if set to <c>true</c> [is detail record] and should not be added to the results dictionary.</param>
-        void HandleMasterDetail<T>(T entry, out bool isDetailRecord)
-        {
-            isDetailRecord = false;
-
-            var masterRecord = entry as IMasterRecord;
-            if (masterRecord != null)
-            {
-                // Found new master record
-                lastMasterRecord = masterRecord;
-                return;
-            }
-
-            // Record is standalone or unassociated detail record
-            if (lastMasterRecord == null) return;
-
-            var detailRecord = entry as IDetailRecord;
-            if (detailRecord == null)
-            {
-                // Record is standalone, reset master
-                lastMasterRecord = null;
-                return;
-            }
-
-            // Add detail record and indicate that it should not be added to the results dictionary
-            lastMasterRecord.DetailRecords.Add(detailRecord);
-            isDetailRecord = true;
-        }
     }
 }
\ No newline at end of file
diff --git a/src/FlatFile.FixedLength/Implementation/MasterDetailTracker.cs b/src/FlatFile.FixedLength/Implementation/MasterDetailTracker.cs
new file mode 100644
index 0000000..2298c29
--- /dev/null
+++ b/src/FlatFile.FixedLength/Implementation/MasterDetailTracker.cs
@@ -0,0 +1,81 @@
+using System;
+
+namespace FlatFile.FixedLength.Implementation
+{
+    /// <summary>
+    /// Uses records that implement <see cref="IMasterRecord"/> and <see cref="IDetailRecord"/> to handle
+    /// master-detail record relationships.
+    /// </summary>
+    public class MasterDetailTracker : IMasterDetailTracker
+    {
+        /// <summary>
+        /// Determines whether a record is a master record.
+        /// </summary>
+        readonly Func<object, bool> checkIsMasterRecord;
+        /// <summary>
+        /// Determines whether a record is a detail record.
+        /// </summary>
+        readonly Func<object, bool> checkIsDetailRecord;
+        /// <summary>
+        /// Handles confirmed detail records.
+        /// </summary>
+        readonly Action<object, object> handleDetailRecord;
+        /// <summary>
+        /// The last record parsed that implements <see cref="IMasterRecord"/>
+        /// </summary>
+        object lastMasterRecord;
+
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MasterDetailTracker"/> class.
+        /// </summary>
+        public MasterDetailTracker()
+            : this(entry => entry is IMasterRecord,
+                   entry => entry is IDetailRecord,
+                   (master, detail) => ((IMasterRecord)master).DetailRecords.Add((IDetailRecord)detail))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MasterDetailTracker"/> class.
+        /// </summary>
+        /// <param name="checkIsMasterRecord">Determines whether a record is a master record.</param>
+        /// <param name="checkIsDetailRecord">Determines whether a record is a detail record.</param>
+        /// <param name="handleDetailRecord">Handles confirmed detail records.</param>
+        public MasterDetailTracker(
+            Func<object, bool> checkIsMasterRecord,
+            Func<object, bool> checkIsDetailRecord,
+            Action<object, object> handleDetailRecord)
+        {
+            this.checkIsMasterRecord = checkIsMasterRecord;
+            this.checkIsDetailRecord = checkIsDetailRecord;
+            this.handleDetailRecord = handleDetailRecord;
+        }
+
+        public void HandleMasterDetail(object entry, out bool isDetailRecord)
+        {
+            isDetailRecord = false;
+
+            if (checkIsMasterRecord(entry))
+            {
+                // Found new master record
+                lastMasterRecord = entry;
+                return;
+            }
+
+            // Record is standalone or unassociated detail record
+            if (lastMasterRecord == null) return;
+
+            if (!checkIsDetailRecord(entry))
+            {
+                // Record is standalone, reset master
+                lastMasterRecord = null;
+                return;
+            }
+
+            // Add detail record and indicate that it should not be added to the results dictionary
+            handleDetailRecord(lastMasterRecord, entry);
+            isDetailRecord = true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailCustomTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailCustomTests.cs
new file mode 100644
index 0000000..48e14ad
--- /dev/null
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailCustomTests.cs
@@ -0,0 +1,191 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using FlatFile.Core;
+using FlatFile.FixedLength;
+using FlatFile.FixedLength.Implementation;
+using FluentAssertions;
+using Xunit;
+
+namespace FlatFile.Tests.FixedLength
+{
+    public class FixedLengthMasterDetailCustomTests
+    {
+        readonly IFlatFileMultiEngine engine;
+
+        const string TestData = @"HHeader                     
+MHeaderLine2                     
+MHeaderLine3                     
+D20150323Some Data                     
+D20150512More Data                     
+HAnotherHeader                     
+D20150511FooBarBaz                     
+SNonHeaderRecord                     
+D20150512Standalone                     ";
+
+        [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
+        public sealed class MasterAttribute : Attribute { }
+
+        [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
+        public sealed class DetailAttribute : Attribute { }
+
+        abstract class RecordBase
+        {
+            public char Type { get; set; }
+            public string Data { get; set; }
+
+            bool Equals(RecordBase other) { return Type == other.Type && string.Equals(Data, other.Data); }
+
+            public override int GetHashCode()
+            {
+                unchecked
+                {
+                    var hashCode = Type.GetHashCode();
+                    hashCode = (hashCode * 397) ^ (Data != null ? Data.GetHashCode() : 0);
+                    return hashCode;
+                }
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (ReferenceEquals(null, obj)) return false;
+                if (ReferenceEquals(this, obj)) return true;
+                return obj.GetType() == GetType() && Equals((RecordBase)obj);
+            }
+        }
+
+        [Master]
+        class HeaderRecord : RecordBase
+        {
+            public IList<DetailRecord> DetailRecords { get; protected set; }
+            public HeaderRecord()
+            {
+                Type = 'H';
+                DetailRecords = new List<DetailRecord>();
+            }
+        }
+
+        class HeaderRecordContinuation : HeaderRecord
+        {
+            public HeaderRecordContinuation()
+            {
+                Type = 'M';
+                DetailRecords = new List<DetailRecord>();
+            }
+        }
+
+        [Detail]
+        class DetailRecord : RecordBase
+        {
+            public DetailRecord() { Type = 'D'; }
+        }
+
+        class StandaloneRecord : RecordBase
+        {
+            public StandaloneRecord() { Type = 'S'; }
+        }
+
+        abstract class RecordBaseLayout<T> : FixedLayout<T> where T : RecordBase
+        {
+            [SuppressMessage("ReSharper", "DoNotCallOverridableMethodsInConstructor")]
+            protected RecordBaseLayout()
+            {
+                WithMember(x => x.Type, c => c.WithLength(1))
+                    .WithMember(x => x.Data, c => c.WithLength(20).WithRightPadding(' '));
+            }
+        }
+
+        class HeaderLayout : RecordBaseLayout<HeaderRecord> { }
+
+        class HeaderContinuationLayout : RecordBaseLayout<HeaderRecordContinuation> { }
+
+        class DetailLayout : RecordBaseLayout<DetailRecord> { }
+
+        class StandaloneLayout : RecordBaseLayout<StandaloneRecord> { }
+
+        public FixedLengthMasterDetailCustomTests()
+        {
+            var layouts = new List<ILayoutDescriptor<IFixedFieldSettingsContainer>>
+            {
+                new HeaderLayout(),
+                new HeaderContinuationLayout(),
+                new DetailLayout(),
+                new StandaloneLayout()
+            };
+            engine = new FixedLengthFileMultiEngine(layouts,
+                                                    (s, i) =>
+                                                    {
+                                                        if (String.IsNullOrEmpty(s) || s.Length < 1) return null;
+
+                                                        switch (s[0])
+                                                        {
+                                                            case 'H':
+                                                                return typeof (HeaderRecord);
+                                                            case 'M':
+                                                                return typeof (HeaderRecordContinuation);
+                                                            case 'S':
+                                                                return typeof (StandaloneRecord);
+                                                            case 'D':
+                                                                return typeof (DetailRecord);
+                                                            default:
+                                                                return null;
+                                                        }
+                                                    },
+                                                    new FixedLengthLineBuilderFactory(),
+                                                    new FixedLengthLineParserFactory(),
+                                                    new MasterDetailTracker(
+                                                        x => x.GetType().GetCustomAttribute<MasterAttribute>(true) != null,
+                                                        x => x.GetType().GetCustomAttribute<DetailAttribute>(true) != null,
+                                                        (master, detail) => ((HeaderRecord)master).DetailRecords.Add((DetailRecord)detail)));
+        }
+
+        [Fact]
+        [SuppressMessage("ReSharper", "PossibleNullReferenceException")]
+        void EngineShouldAssociateDetailRecordsWithPreceedingMasterRecord()
+        {
+            using (var stream = GetStringStream(TestData))
+                engine.Read(stream);
+
+            var headers = engine.GetRecords<HeaderRecord>().ToList();
+            var continuations = engine.GetRecords<HeaderRecordContinuation>().ToList();
+
+            var header1 = headers.FirstOrDefault(r => r.Data == "Header");
+            header1.Should().NotBeNull("The first header record should exist");
+            var header2 = continuations.FirstOrDefault(r => r.Data == "HeaderLine2");
+            header2.Should().NotBeNull("The second header continuation record should exist");
+            var header3 = continuations.FirstOrDefault(r => r.Data == "HeaderLine3");
+            header3.Should().NotBeNull("The third header continuation record should exist");
+
+            header1.DetailRecords.Should().BeNullOrEmpty("It does not have any detail records");
+            header2.DetailRecords.Should().BeNullOrEmpty("It does not have any detail records");
+            header3.DetailRecords.Should().HaveCount(2, "Two detail records exist");
+            
+            var detail = header3.DetailRecords[1] as DetailRecord;
+            detail.Should().NotBeNull("It should be parsed correctly");
+            detail.Data.Should().Be("20150512More Data", "It should preserve ordering");
+
+            var anotherHeader = headers.FirstOrDefault(r => r.Data == "AnotherHeader");
+            anotherHeader.Should().NotBeNull("The other header record should exist");
+            anotherHeader.DetailRecords.Should().HaveCount(1, "One detail record exists");
+
+            var anotherDetail = anotherHeader.DetailRecords[0] as DetailRecord;
+            anotherDetail.Should().NotBeNull("It should be parsed correctly");
+            anotherDetail.Data.Should().Be("20150511FooBarBaz", "It should associate the correct record");
+
+            engine.GetRecords<DetailRecord>().Should().HaveCount(1, "Only unassociated detail records should be available when calling GetRecords<T>");
+        }
+
+        static Stream GetStringStream(string s)
+        {
+            var memoryStream = new MemoryStream();
+            var writer = new StreamWriter(memoryStream);
+            writer.Write(s);
+            writer.Flush();
+            memoryStream.Position = 0;
+            return memoryStream;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailTests.cs
index f80164c..9d330b4 100644
--- a/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailTests.cs
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailTests.cs
@@ -126,7 +126,8 @@ public FixedLengthMasterDetailTests()
                                                         }
                                                     },
                                                     new FixedLengthLineBuilderFactory(),
-                                                    new FixedLengthLineParserFactory());
+                                                    new FixedLengthLineParserFactory(),
+                                                    new MasterDetailTracker());
         }
 
         [Fact]
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthMultiEngineTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthMultiEngineTests.cs
index c94d6a5..6057bba 100644
--- a/src/FlatFile.Tests/FixedLength/FixedLengthMultiEngineTests.cs
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthMultiEngineTests.cs
@@ -115,7 +115,8 @@ public FixedLengthMultiEngineTests()
                                                         }
                                                     },
                                                     new FixedLengthLineBuilderFactory(),
-                                                    new FixedLengthLineParserFactory()) {HasHeader = true};
+                                                    new FixedLengthLineParserFactory(),
+                                                    new MasterDetailTracker()) {HasHeader = true};
         }
 
         [Fact]
diff --git a/src/FlatFile.Tests/FlatFile.Tests.csproj b/src/FlatFile.Tests/FlatFile.Tests.csproj
index 3d02e08..77de885 100644
--- a/src/FlatFile.Tests/FlatFile.Tests.csproj
+++ b/src/FlatFile.Tests/FlatFile.Tests.csproj
@@ -86,6 +86,7 @@
     <Compile Include="Delimited\DelimitedWithHeaderIntegrationTests.cs" />
     <Compile Include="FixedLength\FixedLayoutTests.cs" />
     <Compile Include="FixedLength\FixedLengthAttributeMappingIntegrationTests.cs" />
+    <Compile Include="FixedLength\FixedLengthMasterDetailCustomTests.cs" />
     <Compile Include="FixedLength\FixedLengthIntegrationTests.cs" />
     <Compile Include="FixedLength\FixedLengthLineParserTests.cs" />
     <Compile Include="FixedLength\FixedLengthMasterDetailTests.cs" />

From ad9713e3e8fd32d8dcaad41e59d119990b17ff84 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Sun, 5 Aug 2018 22:03:36 -0500
Subject: [PATCH 03/17] Refactor error handling to use a context object for
 easier introduction of new error handling information and add line number to
 it.

---
 src/FlatFile.Core/Base/FlatFileEngine.cs      |  6 +-
 .../Base/FlatFileErrorContext.cs              | 38 ++++++++
 src/FlatFile.Core/FlatFile.Core.csproj        |  1 +
 .../DelimetedFileMultiEngine.cs               |  6 +-
 .../Implementation/DelimitedFileEngine.cs     |  2 +-
 .../DelimitedFileEngineFactory.cs             | 39 +++++++-
 .../Implementation/FixedLengthFileEngine.cs   |  2 +-
 .../FixedLengthFileEngineFactory.cs           | 39 +++++++-
 .../FixedLengthFileMultiEngine.cs             |  6 +-
 .../Delimited/DelimitedErrorHandlingTests.cs  | 93 ++++++++++++++++++
 .../FixedLengthErrorHandlingTests.cs          | 95 +++++++++++++++++++
 src/FlatFile.Tests/FlatFile.Tests.csproj      | 11 +++
 src/FlatFile.Tests/packages.config            |  1 +
 13 files changed, 325 insertions(+), 14 deletions(-)
 create mode 100644 src/FlatFile.Core/Base/FlatFileErrorContext.cs
 create mode 100644 src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs
 create mode 100644 src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs

diff --git a/src/FlatFile.Core/Base/FlatFileEngine.cs b/src/FlatFile.Core/Base/FlatFileEngine.cs
index 22d18a3..9734114 100644
--- a/src/FlatFile.Core/Base/FlatFileEngine.cs
+++ b/src/FlatFile.Core/Base/FlatFileEngine.cs
@@ -18,7 +18,7 @@ public abstract class FlatFileEngine<TFieldSettings, TLayoutDescriptor> : IFlatF
         /// <summary>
         /// The handle entry read error func
         /// </summary>
-        private readonly Func<string, Exception, bool> _handleEntryReadError;
+        private readonly Func<FlatFileErrorContext, bool> _handleEntryReadError;
 
         /// <summary>
         /// Gets the line builder.
@@ -42,7 +42,7 @@ public abstract class FlatFileEngine<TFieldSettings, TLayoutDescriptor> : IFlatF
         /// Initializes a new instance of the <see cref="FlatFileEngine{TFieldSettings, TLayoutDescriptor}"/> class.
         /// </summary>
         /// <param name="handleEntryReadError">The handle entry read error.</param>
-        protected FlatFileEngine(Func<string, Exception, bool> handleEntryReadError = null)
+        protected FlatFileEngine(Func<FlatFileErrorContext, bool> handleEntryReadError = null)
         {
             _handleEntryReadError = handleEntryReadError;
         }
@@ -85,7 +85,7 @@ protected FlatFileEngine(Func<string, Exception, bool> handleEntryReadError = nu
                         throw;
                     }
 
-                    if (!_handleEntryReadError(line, ex))
+                    if (!_handleEntryReadError(new FlatFileErrorContext(line, lineNumber, ex)))
                     {
                         throw;
                     }
diff --git a/src/FlatFile.Core/Base/FlatFileErrorContext.cs b/src/FlatFile.Core/Base/FlatFileErrorContext.cs
new file mode 100644
index 0000000..35f972c
--- /dev/null
+++ b/src/FlatFile.Core/Base/FlatFileErrorContext.cs
@@ -0,0 +1,38 @@
+namespace FlatFile.Core.Base
+{
+    using System;
+
+    /// <summary>
+    /// Provides information about a file parsing error.
+    /// </summary>
+    public struct FlatFileErrorContext
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="FlatFileErrorContext"/>.
+        /// </summary>
+        /// <param name="line">The content of the line on which the error occurred.</param>
+        /// <param name="lineNumber">The line numer at which the error occurred.</param>
+        /// <param name="exception">The error that occurred.</param>
+        public FlatFileErrorContext(string line, int lineNumber, Exception exception)
+        {
+            Line = line;
+            LineNumber = lineNumber;
+            Exception = exception;
+        }
+
+        /// <summary>
+        /// The content of the line on which the error occurred.
+        /// </summary>
+        public string Line { get; }
+
+        /// <summary>
+        /// The line numer at which the error occurred.
+        /// </summary>
+        public int LineNumber { get; }
+
+        /// <summary>
+        /// The error that occurred.
+        /// </summary>
+        public Exception Exception { get; }
+    }
+}
\ No newline at end of file
diff --git a/src/FlatFile.Core/FlatFile.Core.csproj b/src/FlatFile.Core/FlatFile.Core.csproj
index 08ab631..4c12d6d 100644
--- a/src/FlatFile.Core/FlatFile.Core.csproj
+++ b/src/FlatFile.Core/FlatFile.Core.csproj
@@ -98,6 +98,7 @@
     <Compile Include="Base\FieldsContainer.cs" />
     <Compile Include="Base\FieldSettingsBase.cs" />
     <Compile Include="Base\FlatFileEngine.cs" />
+    <Compile Include="Base\FlatFileErrorContext.cs" />
     <Compile Include="Base\LayoutBase.cs" />
     <Compile Include="Base\LayoutDescriptorBase.cs" />
     <Compile Include="Base\LineBulderBase.cs" />
diff --git a/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs b/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
index 215d974..ff16b8c 100644
--- a/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
@@ -18,7 +18,7 @@ public class DelimitedFileMultiEngine : FlatFileEngine<IDelimitedFieldSettingsCo
         /// <summary>
         /// The handle entry read error func
         /// </summary>
-        readonly Func<string, Exception, bool> handleEntryReadError;
+        readonly Func<FlatFileErrorContext, bool> handleEntryReadError;
         /// <summary>
         /// The layout descriptors for this engine
         /// </summary>
@@ -58,7 +58,7 @@ internal DelimitedFileMultiEngine(
             Func<string, Type> typeSelectorFunc,
             IDelimitedLineBuilderFactory lineBuilderFactory,
             IDelimitedLineParserFactory lineParserFactory,
-            Func<string, Exception, bool> handleEntryReadError = null)
+            Func<FlatFileErrorContext, bool> handleEntryReadError = null)
         {
             if (typeSelectorFunc == null) throw new ArgumentNullException("typeSelectorFunc");
             this.layoutDescriptors = layoutDescriptors.ToList();
@@ -170,7 +170,7 @@ public void Read(Stream stream)
                         throw;
                     }
 
-                    if (!handleEntryReadError(line, ex))
+                    if (!handleEntryReadError(new FlatFileErrorContext(line, lineNumber, ex)))
                     {
                         throw;
                     }
diff --git a/src/FlatFile.Delimited/Implementation/DelimitedFileEngine.cs b/src/FlatFile.Delimited/Implementation/DelimitedFileEngine.cs
index cccbd39..db777ee 100644
--- a/src/FlatFile.Delimited/Implementation/DelimitedFileEngine.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimitedFileEngine.cs
@@ -38,7 +38,7 @@ internal DelimitedFileEngine(
             IDelimitedLayoutDescriptor layoutDescriptor,
             IDelimitedLineBuilderFactory builderFactory,
             IDelimitedLineParserFactory parserFactory, 
-            Func<string, Exception, bool> handleEntryReadError = null)
+            Func<FlatFileErrorContext, bool> handleEntryReadError = null)
             : base(handleEntryReadError)
         {
             _builderFactory = builderFactory;
diff --git a/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs b/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs
index a91ad3a..2d49dcb 100644
--- a/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs
@@ -51,10 +51,25 @@ public IFlatFileEngine GetEngine(
                 descriptor,
                 new DelimitedLineBuilderFactory(),
                 new DelimitedLineParserFactory(),
-                handleEntryReadError);
+                ctx => handleEntryReadError(ctx.Line, ctx.Exception));
         }
 
-
+        /// <summary>
+        /// Gets the <see cref="IFlatFileEngine" />.
+        /// </summary>
+        /// <param name="descriptor">The descriptor.</param>
+        /// <param name="handleEntryReadError">The handle entry read error func.</param>
+        /// <returns>IFlatFileEngine.</returns>
+        public IFlatFileEngine GetEngine(
+            IDelimitedLayoutDescriptor descriptor,
+            Func<FlatFileErrorContext, bool> handleEntryReadError)
+        {
+            return new DelimitedFileEngine(
+                descriptor,
+                new DelimitedLineBuilderFactory(),
+                new DelimitedLineParserFactory(),
+                handleEntryReadError);
+        }
 
         /// <summary>
         /// Gets the <see cref="IFlatFileMultiEngine"/>.
@@ -67,6 +82,26 @@ public IFlatFileMultiEngine GetEngine(
             IEnumerable<IDelimitedLayoutDescriptor> layoutDescriptors,
             Func<string, Type> typeSelectorFunc,
             Func<string, Exception, bool> handleEntryReadError = null)
+        {
+            return new DelimitedFileMultiEngine(
+                layoutDescriptors,
+                typeSelectorFunc,
+                new DelimitedLineBuilderFactory(),
+                lineParserFactory,
+                ctx => handleEntryReadError(ctx.Line, ctx.Exception));
+        }
+
+        /// <summary>
+        /// Gets the <see cref="IFlatFileMultiEngine"/>.
+        /// </summary>
+        /// <param name="layoutDescriptors">The layout descriptors.</param>
+        /// <param name="typeSelectorFunc">The type selector function.</param>
+        /// <param name="handleEntryReadError">The handle entry read error func.</param>
+        /// <returns>IFlatFileMultiEngine.</returns>
+        public IFlatFileMultiEngine GetEngine(
+            IEnumerable<IDelimitedLayoutDescriptor> layoutDescriptors,
+            Func<string, Type> typeSelectorFunc,
+            Func<FlatFileErrorContext, bool> handleEntryReadError)
         {
             return new DelimitedFileMultiEngine(
                 layoutDescriptors,
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngine.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngine.cs
index 22686c9..11770cd 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngine.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngine.cs
@@ -33,7 +33,7 @@ internal FixedLengthFileEngine(
             ILayoutDescriptor<IFixedFieldSettingsContainer> layoutDescriptor,
             IFixedLengthLineBuilderFactory lineBuilderFactory,
             IFixedLengthLineParserFactory lineParserFactory,
-            Func<string, Exception, bool> handleEntryReadError = null) : base(handleEntryReadError)
+            Func<FlatFileErrorContext, bool> handleEntryReadError = null) : base(handleEntryReadError)
         {
             this.lineBuilderFactory = lineBuilderFactory;
             this.lineParserFactory = lineParserFactory;
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
index 132ee69..b3c8a16 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
@@ -48,7 +48,24 @@ public IFlatFileEngine GetEngine(
             return new FixedLengthFileEngine(
                 descriptor, 
                 new FixedLengthLineBuilderFactory(),
-                lineParserFactory, 
+                lineParserFactory,
+                ctx => handleEntryReadError(ctx.Line, ctx.Exception));
+        }
+
+        /// <summary>
+        /// Gets the <see cref="IFlatFileEngine" />.
+        /// </summary>
+        /// <param name="descriptor">The descriptor.</param>
+        /// <param name="handleEntryReadError">The handle entry read error func.</param>
+        /// <returns>IFlatFileEngine.</returns>
+        public IFlatFileEngine GetEngine(
+            ILayoutDescriptor<IFixedFieldSettingsContainer> descriptor,
+            Func<FlatFileErrorContext, bool> handleEntryReadError)
+        {
+            return new FixedLengthFileEngine(
+                descriptor,
+                new FixedLengthLineBuilderFactory(),
+                lineParserFactory,
                 handleEntryReadError);
         }
 
@@ -63,6 +80,26 @@ public IFlatFileMultiEngine GetEngine(
             IEnumerable<ILayoutDescriptor<IFixedFieldSettingsContainer>> layoutDescriptors,
             Func<string, int, Type> typeSelectorFunc,
             Func<string, Exception, bool> handleEntryReadError = null)
+        {
+            return new FixedLengthFileMultiEngine(
+                layoutDescriptors,
+                typeSelectorFunc,
+                new FixedLengthLineBuilderFactory(),
+                lineParserFactory,
+                ctx => handleEntryReadError(ctx.Line, ctx.Exception));
+        }
+
+        /// <summary>
+        /// Gets the <see cref="IFlatFileMultiEngine"/>.
+        /// </summary>
+        /// <param name="layoutDescriptors">The layout descriptors.</param>
+        /// <param name="typeSelectorFunc">The type selector function.</param>
+        /// <param name="handleEntryReadError">The handle entry read error func.</param>
+        /// <returns>IFlatFileMultiEngine.</returns>
+        public IFlatFileMultiEngine GetEngine(
+            IEnumerable<ILayoutDescriptor<IFixedFieldSettingsContainer>> layoutDescriptors,
+            Func<string, int, Type> typeSelectorFunc,
+            Func<FlatFileErrorContext, bool> handleEntryReadError)
         {
             return new FixedLengthFileMultiEngine(
                 layoutDescriptors,
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
index 9226d09..0b238f0 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
@@ -18,7 +18,7 @@ public class FixedLengthFileMultiEngine : FlatFileEngine<IFixedFieldSettingsCont
         /// <summary>
         /// The handle entry read error func
         /// </summary>
-        readonly Func<string, Exception, bool> handleEntryReadError;
+        readonly Func<FlatFileErrorContext, bool> handleEntryReadError;
         /// <summary>
         /// The layout descriptors for this engine
         /// </summary>
@@ -58,7 +58,7 @@ internal FixedLengthFileMultiEngine(
             Func<string, int, Type> typeSelectorFunc,
             IFixedLengthLineBuilderFactory lineBuilderFactory,
             IFixedLengthLineParserFactory lineParserFactory,
-            Func<string, Exception, bool> handleEntryReadError = null)
+            Func<FlatFileErrorContext, bool> handleEntryReadError = null)
         {
             if (typeSelectorFunc == null) throw new ArgumentNullException("typeSelectorFunc");
             this.layoutDescriptors = layoutDescriptors.ToList();
@@ -191,7 +191,7 @@ private void ReadInternal(StreamReader reader)
                         throw;
                     }
 
-                    if (!handleEntryReadError(line, ex))
+                    if (!handleEntryReadError(new FlatFileErrorContext(line, lineNumber, ex)))
                     {
                         throw;
                     }
diff --git a/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs b/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs
new file mode 100644
index 0000000..cdc5593
--- /dev/null
+++ b/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs
@@ -0,0 +1,93 @@
+using FakeItEasy;
+using FlatFile.Core.Base;
+using FlatFile.Delimited;
+using FlatFile.Delimited.Implementation;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Xunit;
+
+namespace FlatFile.Tests.Delimited
+{
+    public class DelimitedErrorHandlingTests
+    {
+        private IDelimitedLayoutDescriptor layout;
+        readonly IDelimitedLineParserFactory lineParserFactory;
+        readonly IList<FlatFileErrorContext> errorContexts = new List<FlatFileErrorContext>();
+
+        const string TestData = 
+@"S,Test Description,00042
+S,Test Description,00043
+S,Test Description,00044";
+
+        public DelimitedErrorHandlingTests()
+        {
+            layout = A.Fake<IDelimitedLayoutDescriptor>();
+            A.CallTo(() => layout.TargetType).Returns(typeof(Record));
+
+            lineParserFactory = A.Fake<IDelimitedLineParserFactory>();
+            A.CallTo(() => lineParserFactory.GetParser(A<IDelimitedLayoutDescriptor>.Ignored))
+                .Returns(new FakeLineParser());
+                
+                new DelimitedLineParserFactory(new Dictionary<Type, Type>
+            {
+                [typeof(Record)] = typeof(FakeLineParser)
+            });
+        }
+
+        [Fact]
+        public void ErrorContextShouldProvideAccurateInformation()
+        {
+            var engine = new DelimitedFileEngine(
+                layout,
+                A.Fake<IDelimitedLineBuilderFactory>(),
+                lineParserFactory,
+                HandleError);
+
+            using (var stream = new MemoryStream(Encoding.Default.GetBytes(TestData)))
+                engine.Read<Record>(stream).ToList();
+
+            Assert.Equal(3, errorContexts.Count);
+            Assert.Equal(new[] { 1, 2, 3 }, errorContexts.Select(ctx => ctx.LineNumber));
+            Assert.Equal(TestData.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries), errorContexts.Select(ctx => ctx.Line));
+            Assert.All(errorContexts, ctx => Assert.Equal("Parsing failed!", ctx.Exception.Message));
+        }
+
+        [Fact]
+        public void MultiEngineErrorContextShouldProvideAccurateInformation()
+        {
+            var engine = new DelimitedFileMultiEngine(
+                new[] { layout },
+                l => typeof(Record),
+                A.Fake<IDelimitedLineBuilderFactory>(),
+                lineParserFactory,
+                HandleError);
+
+            using (var stream = new MemoryStream(Encoding.Default.GetBytes(TestData)))
+                engine.Read(stream);
+
+            Assert.Equal(3, errorContexts.Count);
+            Assert.Equal(new[] { 1, 2, 3 }, errorContexts.Select(ctx => ctx.LineNumber));
+            Assert.Equal(TestData.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries), errorContexts.Select(ctx => ctx.Line));
+            Assert.All(errorContexts, ctx => Assert.Equal("Parsing failed!", ctx.Exception.Message));
+        }
+
+        private bool HandleError(FlatFileErrorContext context)
+        {
+            errorContexts.Add(context);
+            return true;
+        }
+
+        private class FakeLineParser : IDelimitedLineParser
+        {
+            public TEntity ParseLine<TEntity>(string line, TEntity entity) where TEntity : new()
+            {
+                throw new Exception("Parsing failed!");
+            }
+        }
+
+        private class Record { }
+    }
+}
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs
new file mode 100644
index 0000000..d400cb0
--- /dev/null
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs
@@ -0,0 +1,95 @@
+using FakeItEasy;
+using FlatFile.Core;
+using FlatFile.Core.Base;
+using FlatFile.FixedLength;
+using FlatFile.FixedLength.Implementation;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Xunit;
+
+namespace FlatFile.Tests.FixedLength
+{
+    public class FixedLengthErrorHandlingTests
+    {
+        private ILayoutDescriptor<IFixedFieldSettingsContainer> layout;
+        readonly IFixedLengthLineParserFactory lineParserFactory;
+        readonly IList<FlatFileErrorContext> errorContexts = new List<FlatFileErrorContext>();
+
+        const string TestData = 
+@"STest Description    00042
+STest Description    00043
+STest Description    00044";
+
+        public FixedLengthErrorHandlingTests()
+        {
+            layout = A.Fake<ILayoutDescriptor<IFixedFieldSettingsContainer>>();
+            A.CallTo(() => layout.TargetType).Returns(typeof(Record));
+
+            lineParserFactory = new FixedLengthLineParserFactory(new Dictionary<Type, Type>
+            {
+                [typeof(Record)] = typeof(FakeLineParser)
+            });
+        }
+
+        [Fact]
+        public void ErrorContextShouldProvideAccurateInformation()
+        {
+            var engine = new FixedLengthFileEngine(
+                layout,
+                A.Fake<IFixedLengthLineBuilderFactory>(),
+                lineParserFactory,
+                HandleError);
+
+            using (var stream = new MemoryStream(Encoding.Default.GetBytes(TestData)))
+                engine.Read<Record>(stream).ToList();
+
+            Assert.Equal(3, errorContexts.Count);
+            Assert.Equal(new[] { 1, 2, 3 }, errorContexts.Select(ctx => ctx.LineNumber));
+            Assert.Equal(TestData.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries), errorContexts.Select(ctx => ctx.Line));
+            Assert.All(errorContexts, ctx => Assert.Equal("Parsing failed!", ctx.Exception.Message));
+        }
+
+        [Fact]
+        public void MultiEngineErrorContextShouldProvideAccurateInformation()
+        {
+            var engine = new FixedLengthFileMultiEngine(
+                new[] { layout },
+                (l, i) => typeof(Record),
+                A.Fake<IFixedLengthLineBuilderFactory>(),
+                lineParserFactory,
+                HandleError);
+
+            using (var stream = new MemoryStream(Encoding.Default.GetBytes(TestData)))
+                engine.Read(stream);
+
+            Assert.Equal(3, errorContexts.Count);
+            Assert.Equal(new[] { 1, 2, 3 }, errorContexts.Select(ctx => ctx.LineNumber));
+            Assert.Equal(TestData.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries), errorContexts.Select(ctx => ctx.Line));
+            Assert.All(errorContexts, ctx => Assert.Equal("Parsing failed!", ctx.Exception.Message));
+        }
+
+        private bool HandleError(FlatFileErrorContext context)
+        {
+            errorContexts.Add(context);
+            return true;
+        }
+
+        private class FakeLineParser : IFixedLengthLineParser
+        {
+            public FakeLineParser(ILayoutDescriptor<IFixedFieldSettingsContainer> descriptor)
+            {
+
+            }
+
+            public TEntity ParseLine<TEntity>(string line, TEntity entity) where TEntity : new()
+            {
+                throw new Exception("Parsing failed!");
+            }
+        }
+
+        private class Record { }
+    }
+}
diff --git a/src/FlatFile.Tests/FlatFile.Tests.csproj b/src/FlatFile.Tests/FlatFile.Tests.csproj
index 57f98f9..90bead5 100644
--- a/src/FlatFile.Tests/FlatFile.Tests.csproj
+++ b/src/FlatFile.Tests/FlatFile.Tests.csproj
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props" Condition="Exists('..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props')" />
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -13,6 +14,8 @@
     <FileAlignment>512</FileAlignment>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -81,8 +84,10 @@
     <Compile Include="Delimited\DelimitedLayoutTests.cs" />
     <Compile Include="Delimited\DelimitedMultiEngineTests.cs" />
     <Compile Include="Delimited\DelimitedWithHeaderIntegrationTests.cs" />
+    <Compile Include="Delimited\DelimitedErrorHandlingTests.cs" />
     <Compile Include="FixedLength\FixedLayoutTests.cs" />
     <Compile Include="FixedLength\FixedLengthAttributeMappingIntegrationTests.cs" />
+    <Compile Include="FixedLength\FixedLengthErrorHandlingTests.cs" />
     <Compile Include="FixedLength\FixedLengthIntegrationTests.cs" />
     <Compile Include="FixedLength\FixedLengthLineParserTests.cs" />
     <Compile Include="FixedLength\FixedLengthMasterDetailTests.cs" />
@@ -138,6 +143,12 @@
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props'))" />
+  </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/src/FlatFile.Tests/packages.config b/src/FlatFile.Tests/packages.config
index 0f982a6..1357199 100644
--- a/src/FlatFile.Tests/packages.config
+++ b/src/FlatFile.Tests/packages.config
@@ -11,4 +11,5 @@
   <package id="xunit.extensibility.core" version="2.1.0" targetFramework="net45" />
   <package id="xunit.extensibility.execution" version="2.1.0" targetFramework="net45" />
   <package id="xunit.runner.console" version="2.1.0" targetFramework="net45" />
+  <package id="xunit.runner.visualstudio" version="2.1.0" targetFramework="net45" />
 </packages>
\ No newline at end of file

From 7a05b266a48a14d10d9b4a633bd1f6c728bd5f44 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Sun, 5 Aug 2018 22:33:40 -0500
Subject: [PATCH 04/17] Add support for delimited files.

---
 .../Base/MasterDetailTrackerBase.cs}          | 17 ++-----
 src/FlatFile.Core/FlatFile.Core.csproj        |  2 +
 .../IMasterDetailTracker.cs                   |  2 +-
 .../FlatFileEngineFactoryExtensions.cs        |  6 ++-
 .../FlatFile.Delimited.csproj                 |  1 +
 .../DelimetedFileMultiEngine.cs               | 44 +++----------------
 .../DelimitedFileEngineFactory.cs             |  5 ++-
 .../DelimitedMasterDetailTracker.cs           | 21 +++++++++
 .../FlatFile.FixedLength.csproj               |  3 +-
 .../FixedLengthFileEngineFactory.cs           |  2 +-
 .../FixedLengthMasterDetailTracker.cs         | 21 +++++++++
 .../FixedLengthMasterDetailCustomTests.cs     |  3 +-
 .../FixedLengthMasterDetailTests.cs           |  2 +-
 .../FixedLengthMultiEngineTests.cs            |  2 +-
 14 files changed, 68 insertions(+), 63 deletions(-)
 rename src/{FlatFile.FixedLength/Implementation/MasterDetailTracker.cs => FlatFile.Core/Base/MasterDetailTrackerBase.cs} (81%)
 rename src/{FlatFile.FixedLength => FlatFile.Core}/IMasterDetailTracker.cs (87%)
 create mode 100644 src/FlatFile.Delimited/Implementation/DelimitedMasterDetailTracker.cs
 create mode 100644 src/FlatFile.FixedLength/Implementation/FixedLengthMasterDetailTracker.cs

diff --git a/src/FlatFile.FixedLength/Implementation/MasterDetailTracker.cs b/src/FlatFile.Core/Base/MasterDetailTrackerBase.cs
similarity index 81%
rename from src/FlatFile.FixedLength/Implementation/MasterDetailTracker.cs
rename to src/FlatFile.Core/Base/MasterDetailTrackerBase.cs
index 2298c29..51bd660 100644
--- a/src/FlatFile.FixedLength/Implementation/MasterDetailTracker.cs
+++ b/src/FlatFile.Core/Base/MasterDetailTrackerBase.cs
@@ -1,12 +1,12 @@
 using System;
 
-namespace FlatFile.FixedLength.Implementation
+namespace FlatFile.Core.Base
 {
     /// <summary>
     /// Uses records that implement <see cref="IMasterRecord"/> and <see cref="IDetailRecord"/> to handle
     /// master-detail record relationships.
     /// </summary>
-    public class MasterDetailTracker : IMasterDetailTracker
+    public class MasterDetailTrackerBase : IMasterDetailTracker
     {
         /// <summary>
         /// Determines whether a record is a master record.
@@ -25,24 +25,13 @@ public class MasterDetailTracker : IMasterDetailTracker
         /// </summary>
         object lastMasterRecord;
 
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="MasterDetailTracker"/> class.
-        /// </summary>
-        public MasterDetailTracker()
-            : this(entry => entry is IMasterRecord,
-                   entry => entry is IDetailRecord,
-                   (master, detail) => ((IMasterRecord)master).DetailRecords.Add((IDetailRecord)detail))
-        {
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="MasterDetailTracker"/> class.
         /// </summary>
         /// <param name="checkIsMasterRecord">Determines whether a record is a master record.</param>
         /// <param name="checkIsDetailRecord">Determines whether a record is a detail record.</param>
         /// <param name="handleDetailRecord">Handles confirmed detail records.</param>
-        public MasterDetailTracker(
+        public MasterDetailTrackerBase(
             Func<object, bool> checkIsMasterRecord,
             Func<object, bool> checkIsDetailRecord,
             Action<object, object> handleDetailRecord)
diff --git a/src/FlatFile.Core/FlatFile.Core.csproj b/src/FlatFile.Core/FlatFile.Core.csproj
index 08ab631..2cc355e 100644
--- a/src/FlatFile.Core/FlatFile.Core.csproj
+++ b/src/FlatFile.Core/FlatFile.Core.csproj
@@ -95,6 +95,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Base\MasterDetailTrackerBase.cs" />
     <Compile Include="Base\FieldsContainer.cs" />
     <Compile Include="Base\FieldSettingsBase.cs" />
     <Compile Include="Base\FlatFileEngine.cs" />
@@ -120,6 +121,7 @@
     <Compile Include="ILineBulder.cs" />
     <Compile Include="ILineParser.cs" />
     <Compile Include="ILineParserFactory.cs" />
+    <Compile Include="IMasterDetailTracker.cs" />
     <Compile Include="ITypeConverter.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
diff --git a/src/FlatFile.FixedLength/IMasterDetailTracker.cs b/src/FlatFile.Core/IMasterDetailTracker.cs
similarity index 87%
rename from src/FlatFile.FixedLength/IMasterDetailTracker.cs
rename to src/FlatFile.Core/IMasterDetailTracker.cs
index 5ab96d0..49755df 100644
--- a/src/FlatFile.FixedLength/IMasterDetailTracker.cs
+++ b/src/FlatFile.Core/IMasterDetailTracker.cs
@@ -1,4 +1,4 @@
-namespace FlatFile.FixedLength
+namespace FlatFile.Core
 {
     /// <summary>
     /// Determines how master-detail record relationships are handled.
diff --git a/src/FlatFile.Delimited.Attributes/FlatFileEngineFactoryExtensions.cs b/src/FlatFile.Delimited.Attributes/FlatFileEngineFactoryExtensions.cs
index df16159..23a1e86 100644
--- a/src/FlatFile.Delimited.Attributes/FlatFileEngineFactoryExtensions.cs
+++ b/src/FlatFile.Delimited.Attributes/FlatFileEngineFactoryExtensions.cs
@@ -37,16 +37,18 @@ public static IFlatFileEngine GetEngine<TEntity>(
         /// <param name="recordTypes">The record types.</param>
         /// <param name="typeSelectorFunc">The type selector function.</param>
         /// <param name="handleEntryReadError">The handle entry read error.</param>
+        /// <param name="masterDetailTracker">Determines how master-detail record relationships are handled.</param>
         /// <returns>IFlatFileMultiEngine.</returns>
         public static IFlatFileMultiEngine GetEngine(
             this DelimitedFileEngineFactory engineFactory,
             IEnumerable<Type> recordTypes,
             Func<string, Type> typeSelectorFunc,
-            Func<string, Exception, bool> handleEntryReadError = null)
+            Func<string, Exception, bool> handleEntryReadError = null,
+            IMasterDetailTracker masterDetailTracker = null)
         {
             var descriptorProvider = new DelimitedLayoutDescriptorProvider();
             var descriptors = recordTypes.Select(type => descriptorProvider.GetDescriptor(type)).ToList();
-            return engineFactory.GetEngine(descriptors, typeSelectorFunc, handleEntryReadError);
+            return engineFactory.GetEngine(descriptors, typeSelectorFunc, handleEntryReadError, masterDetailTracker);
         }
     }
 }
\ No newline at end of file
diff --git a/src/FlatFile.Delimited/FlatFile.Delimited.csproj b/src/FlatFile.Delimited/FlatFile.Delimited.csproj
index 1523482..b7a87a8 100644
--- a/src/FlatFile.Delimited/FlatFile.Delimited.csproj
+++ b/src/FlatFile.Delimited/FlatFile.Delimited.csproj
@@ -113,6 +113,7 @@
     <Compile Include="Implementation\DelimitedLineBuilderFactory.cs" />
     <Compile Include="Implementation\DelimitedLineParser.cs" />
     <Compile Include="Implementation\DelimitedLineParserFactory.cs" />
+    <Compile Include="Implementation\DelimitedMasterDetailTracker.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs b/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
index 215d974..a346a25 100644
--- a/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
@@ -40,9 +40,9 @@ public class DelimitedFileMultiEngine : FlatFileEngine<IDelimitedFieldSettingsCo
         /// </summary>
         readonly Dictionary<Type, ArrayList> results;
         /// <summary>
-        /// The last record parsed that implements <see cref="IMasterRecord"/>
+        /// Determines how master-detail record relationships are handled.
         /// </summary>
-        IMasterRecord lastMasterRecord;
+        readonly IMasterDetailTracker masterDetailTracker;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DelimetedFileMultiEngine"/> class.
@@ -58,6 +58,7 @@ internal DelimitedFileMultiEngine(
             Func<string, Type> typeSelectorFunc,
             IDelimitedLineBuilderFactory lineBuilderFactory,
             IDelimitedLineParserFactory lineParserFactory,
+            IMasterDetailTracker masterDetailTracker,
             Func<string, Exception, bool> handleEntryReadError = null)
         {
             if (typeSelectorFunc == null) throw new ArgumentNullException("typeSelectorFunc");
@@ -70,6 +71,7 @@ internal DelimitedFileMultiEngine(
             this.typeSelectorFunc = typeSelectorFunc;
             this.lineBuilderFactory = lineBuilderFactory;
             this.lineParserFactory = lineParserFactory;
+            this.masterDetailTracker = masterDetailTracker;
             this.handleEntryReadError = handleEntryReadError;
         }
 
@@ -181,48 +183,12 @@ public void Read(Stream stream)
                 if (ignoreEntry) continue;
 
                 bool isDetailRecord;
-                HandleMasterDetail(entry, out isDetailRecord);
+                masterDetailTracker.HandleMasterDetail(entry, out isDetailRecord);
 
                 if (isDetailRecord) continue;
 
                 results[type].Add(entry);
             }
         }
-
-
-        /// <summary>
-        /// Handles any master/detail relationships for this <paramref name="entry"/>.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="entry">The entry.</param>
-        /// <param name="isDetailRecord">if set to <c>true</c> [is detail record] and should not be added to the results dictionary.</param>
-        void HandleMasterDetail<T>(T entry, out bool isDetailRecord)
-        {
-            isDetailRecord = false;
-
-            var masterRecord = entry as IMasterRecord;
-            if (masterRecord != null)
-            {
-                // Found new master record
-                lastMasterRecord = masterRecord;
-                return;
-            }
-
-            // Record is standalone or unassociated detail record
-            if (lastMasterRecord == null) return;
-
-            var detailRecord = entry as IDetailRecord;
-            if (detailRecord == null)
-            {
-                // Record is standalone, reset master
-                lastMasterRecord = null;
-                return;
-            }
-
-            // Add detail record and indicate that it should not be added to the results dictionary
-            lastMasterRecord.DetailRecords.Add(detailRecord);
-            isDetailRecord = true;
-        }
-        
     }
 }
diff --git a/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs b/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs
index a91ad3a..7f4ad8a 100644
--- a/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs
@@ -62,17 +62,20 @@ public IFlatFileEngine GetEngine(
         /// <param name="layoutDescriptors">The layout descriptors.</param>
         /// <param name="typeSelectorFunc">The type selector function.</param>
         /// <param name="handleEntryReadError">The handle entry read error func.</param>
+        /// <param name="masterDetailTracker">Determines how master-detail record relationships are handled.</param>
         /// <returns>IFlatFileMultiEngine.</returns>
         public IFlatFileMultiEngine GetEngine(
             IEnumerable<IDelimitedLayoutDescriptor> layoutDescriptors,
             Func<string, Type> typeSelectorFunc,
-            Func<string, Exception, bool> handleEntryReadError = null)
+            Func<string, Exception, bool> handleEntryReadError = null,
+            IMasterDetailTracker masterDetailTracker = null)
         {
             return new DelimitedFileMultiEngine(
                 layoutDescriptors,
                 typeSelectorFunc,
                 new DelimitedLineBuilderFactory(),
                 lineParserFactory,
+                masterDetailTracker ?? new DelimitedMasterDetailTracker(),
                 handleEntryReadError);
         }
     }
diff --git a/src/FlatFile.Delimited/Implementation/DelimitedMasterDetailTracker.cs b/src/FlatFile.Delimited/Implementation/DelimitedMasterDetailTracker.cs
new file mode 100644
index 0000000..be46a0d
--- /dev/null
+++ b/src/FlatFile.Delimited/Implementation/DelimitedMasterDetailTracker.cs
@@ -0,0 +1,21 @@
+using FlatFile.Core.Base;
+
+namespace FlatFile.Delimited.Implementation
+{
+    /// <summary>
+    /// Uses records that implement <see cref="IMasterRecord"/> and <see cref="IDetailRecord"/> to handle
+    /// master-detail record relationships.
+    /// </summary>
+    public class DelimitedMasterDetailTracker : MasterDetailTrackerBase
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MasterDetailTracker"/> class.
+        /// </summary>
+        public DelimitedMasterDetailTracker()
+            : base(entry => entry is IMasterRecord,
+                   entry => entry is IDetailRecord,
+                   (master, detail) => ((IMasterRecord)master).DetailRecords.Add((IDetailRecord)detail))
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/FlatFile.FixedLength/FlatFile.FixedLength.csproj b/src/FlatFile.FixedLength/FlatFile.FixedLength.csproj
index bbfc578..9e17617 100644
--- a/src/FlatFile.FixedLength/FlatFile.FixedLength.csproj
+++ b/src/FlatFile.FixedLength/FlatFile.FixedLength.csproj
@@ -95,7 +95,6 @@
   <ItemGroup>
     <Compile Include="FixedFieldSettings.cs" />
     <Compile Include="IDetailRecord.cs" />
-    <Compile Include="IMasterDetailTracker.cs" />
     <Compile Include="IMasterRecord.cs" />
     <Compile Include="Implementation\FixedLengthFileMultiEngine.cs" />
     <Compile Include="IFixedFieldSettingsConstructor.cs" />
@@ -113,7 +112,7 @@
     <Compile Include="Implementation\FixedLengthLineBuilderFactory.cs" />
     <Compile Include="Implementation\FixedLengthLineParser.cs" />
     <Compile Include="Implementation\FixedLengthLineParserFactory.cs" />
-    <Compile Include="Implementation\MasterDetailTracker.cs" />
+    <Compile Include="Implementation\FixedLengthMasterDetailTracker.cs" />
     <Compile Include="Padding.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
index 96257fa..7ada733 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
@@ -71,7 +71,7 @@ public IFlatFileMultiEngine GetEngine(
                 typeSelectorFunc,
                 new FixedLengthLineBuilderFactory(),
                 lineParserFactory,
-                masterDetailTracker ?? new MasterDetailTracker(),
+                masterDetailTracker ?? new FixedLengthMasterDetailTracker(),
                 handleEntryReadError);
         }
     }
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthMasterDetailTracker.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthMasterDetailTracker.cs
new file mode 100644
index 0000000..62bb7bc
--- /dev/null
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthMasterDetailTracker.cs
@@ -0,0 +1,21 @@
+using FlatFile.Core.Base;
+
+namespace FlatFile.FixedLength.Implementation
+{
+    /// <summary>
+    /// Uses records that implement <see cref="IMasterRecord"/> and <see cref="IDetailRecord"/> to handle
+    /// master-detail record relationships.
+    /// </summary>
+    public class FixedLengthMasterDetailTracker : MasterDetailTrackerBase
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FixedLengthMasterDetailTracker"/> class.
+        /// </summary>
+        public FixedLengthMasterDetailTracker()
+            : base(entry => entry is IMasterRecord,
+                   entry => entry is IDetailRecord,
+                   (master, detail) => ((IMasterRecord)master).DetailRecords.Add((IDetailRecord)detail))
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailCustomTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailCustomTests.cs
index 48e14ad..c8335ec 100644
--- a/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailCustomTests.cs
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailCustomTests.cs
@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Reflection;
 using FlatFile.Core;
+using FlatFile.Core.Base;
 using FlatFile.FixedLength;
 using FlatFile.FixedLength.Implementation;
 using FluentAssertions;
@@ -136,7 +137,7 @@ public FixedLengthMasterDetailCustomTests()
                                                     },
                                                     new FixedLengthLineBuilderFactory(),
                                                     new FixedLengthLineParserFactory(),
-                                                    new MasterDetailTracker(
+                                                    new MasterDetailTrackerBase(
                                                         x => x.GetType().GetCustomAttribute<MasterAttribute>(true) != null,
                                                         x => x.GetType().GetCustomAttribute<DetailAttribute>(true) != null,
                                                         (master, detail) => ((HeaderRecord)master).DetailRecords.Add((DetailRecord)detail)));
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailTests.cs
index 9d330b4..2ebcfaf 100644
--- a/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailTests.cs
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthMasterDetailTests.cs
@@ -127,7 +127,7 @@ public FixedLengthMasterDetailTests()
                                                     },
                                                     new FixedLengthLineBuilderFactory(),
                                                     new FixedLengthLineParserFactory(),
-                                                    new MasterDetailTracker());
+                                                    new FixedLengthMasterDetailTracker());
         }
 
         [Fact]
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthMultiEngineTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthMultiEngineTests.cs
index 6057bba..bfe8074 100644
--- a/src/FlatFile.Tests/FixedLength/FixedLengthMultiEngineTests.cs
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthMultiEngineTests.cs
@@ -116,7 +116,7 @@ public FixedLengthMultiEngineTests()
                                                     },
                                                     new FixedLengthLineBuilderFactory(),
                                                     new FixedLengthLineParserFactory(),
-                                                    new MasterDetailTracker()) {HasHeader = true};
+                                                    new FixedLengthMasterDetailTracker()) {HasHeader = true};
         }
 
         [Fact]

From 1680cdcde2c3609c2869d05d1c0bbe3f397014d6 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Sun, 5 Aug 2018 22:39:45 -0500
Subject: [PATCH 05/17] Fix build error.

---
 src/FlatFile.Core/Base/FlatFileErrorContext.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/FlatFile.Core/Base/FlatFileErrorContext.cs b/src/FlatFile.Core/Base/FlatFileErrorContext.cs
index 35f972c..d72fec6 100644
--- a/src/FlatFile.Core/Base/FlatFileErrorContext.cs
+++ b/src/FlatFile.Core/Base/FlatFileErrorContext.cs
@@ -23,16 +23,16 @@ public FlatFileErrorContext(string line, int lineNumber, Exception exception)
         /// <summary>
         /// The content of the line on which the error occurred.
         /// </summary>
-        public string Line { get; }
+        public string Line { get; private set; }
 
         /// <summary>
         /// The line numer at which the error occurred.
         /// </summary>
-        public int LineNumber { get; }
+        public int LineNumber { get; private set; }
 
         /// <summary>
         /// The error that occurred.
         /// </summary>
-        public Exception Exception { get; }
+        public Exception Exception { get; private set; }
     }
 }
\ No newline at end of file

From 8c9b188a0c049abcd360895de90058440de19305 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Sun, 5 Aug 2018 22:51:28 -0500
Subject: [PATCH 06/17] Fix more build errors.

---
 .../Base/FlatFileErrorContext.cs              | 25 ++++++++++++++-----
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/src/FlatFile.Core/Base/FlatFileErrorContext.cs b/src/FlatFile.Core/Base/FlatFileErrorContext.cs
index d72fec6..eb48237 100644
--- a/src/FlatFile.Core/Base/FlatFileErrorContext.cs
+++ b/src/FlatFile.Core/Base/FlatFileErrorContext.cs
@@ -7,6 +7,10 @@
     /// </summary>
     public struct FlatFileErrorContext
     {
+        private readonly string line;
+        private readonly int lineNumber;
+        private readonly Exception exception;
+
         /// <summary>
         /// Initializes a new instance of <see cref="FlatFileErrorContext"/>.
         /// </summary>
@@ -15,24 +19,33 @@ public struct FlatFileErrorContext
         /// <param name="exception">The error that occurred.</param>
         public FlatFileErrorContext(string line, int lineNumber, Exception exception)
         {
-            Line = line;
-            LineNumber = lineNumber;
-            Exception = exception;
+            this.line = line;
+            this.lineNumber = lineNumber;
+            this.exception = exception;
         }
 
         /// <summary>
         /// The content of the line on which the error occurred.
         /// </summary>
-        public string Line { get; private set; }
+        public string Line
+        {
+            get { return line; }
+        }
 
         /// <summary>
         /// The line numer at which the error occurred.
         /// </summary>
-        public int LineNumber { get; private set; }
+        public int LineNumber
+        {
+            get { return lineNumber; }
+        }
 
         /// <summary>
         /// The error that occurred.
         /// </summary>
-        public Exception Exception { get; private set; }
+        public Exception Exception
+        {
+            get { return exception; }
+        }
     }
 }
\ No newline at end of file

From 48ed5c8c904f34f1395b72bd7f3ee77ad383b17e Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Sun, 5 Aug 2018 22:54:16 -0500
Subject: [PATCH 07/17] Use older dictionary initializer syntax.

---
 src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs   | 4 ++--
 .../FixedLength/FixedLengthErrorHandlingTests.cs              | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs b/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs
index cdc5593..9793731 100644
--- a/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs
+++ b/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs
@@ -31,9 +31,9 @@ public DelimitedErrorHandlingTests()
             A.CallTo(() => lineParserFactory.GetParser(A<IDelimitedLayoutDescriptor>.Ignored))
                 .Returns(new FakeLineParser());
                 
-                new DelimitedLineParserFactory(new Dictionary<Type, Type>
+            new DelimitedLineParserFactory(new Dictionary<Type, Type>
             {
-                [typeof(Record)] = typeof(FakeLineParser)
+                { typeof(Record), typeof(FakeLineParser) }
             });
         }
 
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs
index d400cb0..c2bbb98 100644
--- a/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs
@@ -30,7 +30,7 @@ public FixedLengthErrorHandlingTests()
 
             lineParserFactory = new FixedLengthLineParserFactory(new Dictionary<Type, Type>
             {
-                [typeof(Record)] = typeof(FakeLineParser)
+                { typeof(Record),  typeof(FakeLineParser) }
             });
         }
 

From 06e55af210ce1d33f0974b5de94316ec1f446de9 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Mon, 6 Aug 2018 21:21:16 -0500
Subject: [PATCH 08/17] Fix spelling of 'builder'.

---
 src/FlatFile.Core/Base/FlatFileEngine.cs                      | 2 +-
 .../Base/{LineBulderBase.cs => LineBuilderBase.cs}            | 4 ++--
 src/FlatFile.Core/FlatFile.Core.csproj                        | 4 ++--
 src/FlatFile.Core/{ILineBulder.cs => ILineBuilder.cs}         | 2 +-
 src/FlatFile.Core/ILineBuilderFactory.cs                      | 2 +-
 src/FlatFile.Delimited/IDelimitedLineBuilder.cs               | 2 +-
 .../Implementation/DelimetedFileMultiEngine.cs                | 2 +-
 src/FlatFile.Delimited/Implementation/DelimitedFileEngine.cs  | 2 +-
 src/FlatFile.Delimited/Implementation/DelimitedLineBuilder.cs | 2 +-
 src/FlatFile.FixedLength/IFixedLengthLineBuilder.cs           | 2 +-
 .../Implementation/FixedLengthFileEngine.cs                   | 2 +-
 .../Implementation/FixedLengthFileMultiEngine.cs              | 2 +-
 .../Implementation/FixedLengthLineBuilder.cs                  | 2 +-
 13 files changed, 15 insertions(+), 15 deletions(-)
 rename src/FlatFile.Core/Base/{LineBulderBase.cs => LineBuilderBase.cs} (85%)
 rename src/FlatFile.Core/{ILineBulder.cs => ILineBuilder.cs} (69%)

diff --git a/src/FlatFile.Core/Base/FlatFileEngine.cs b/src/FlatFile.Core/Base/FlatFileEngine.cs
index 22d18a3..d87d3d5 100644
--- a/src/FlatFile.Core/Base/FlatFileEngine.cs
+++ b/src/FlatFile.Core/Base/FlatFileEngine.cs
@@ -24,7 +24,7 @@ public abstract class FlatFileEngine<TFieldSettings, TLayoutDescriptor> : IFlatF
         /// Gets the line builder.
         /// </summary>
         /// <value>The line builder.</value>
-        protected abstract ILineBulder LineBuilder { get; }
+        protected abstract ILineBuilder LineBuilder { get; }
 
         /// <summary>
         /// Gets the line parser.
diff --git a/src/FlatFile.Core/Base/LineBulderBase.cs b/src/FlatFile.Core/Base/LineBuilderBase.cs
similarity index 85%
rename from src/FlatFile.Core/Base/LineBulderBase.cs
rename to src/FlatFile.Core/Base/LineBuilderBase.cs
index 1bbfa2d..8a6797e 100644
--- a/src/FlatFile.Core/Base/LineBulderBase.cs
+++ b/src/FlatFile.Core/Base/LineBuilderBase.cs
@@ -1,12 +1,12 @@
 namespace FlatFile.Core.Base
 {
-    public abstract class LineBulderBase<TLayoutDescriptor, TFieldSettings> : ILineBulder
+    public abstract class LineBuilderBase<TLayoutDescriptor, TFieldSettings> : ILineBuilder
         where TLayoutDescriptor : ILayoutDescriptor<TFieldSettings>
         where TFieldSettings : IFieldSettingsContainer 
     {
         private readonly TLayoutDescriptor _descriptor;
 
-        protected LineBulderBase(TLayoutDescriptor descriptor)
+        protected LineBuilderBase(TLayoutDescriptor descriptor)
         {
             this._descriptor = descriptor;
         }
diff --git a/src/FlatFile.Core/FlatFile.Core.csproj b/src/FlatFile.Core/FlatFile.Core.csproj
index 08ab631..d20d4cf 100644
--- a/src/FlatFile.Core/FlatFile.Core.csproj
+++ b/src/FlatFile.Core/FlatFile.Core.csproj
@@ -100,7 +100,7 @@
     <Compile Include="Base\FlatFileEngine.cs" />
     <Compile Include="Base\LayoutBase.cs" />
     <Compile Include="Base\LayoutDescriptorBase.cs" />
-    <Compile Include="Base\LineBulderBase.cs" />
+    <Compile Include="Base\LineBuilderBase.cs" />
     <Compile Include="Base\LineParserBase.cs" />
     <Compile Include="Exceptions\ParseLineException.cs" />
     <Compile Include="Extensions\ExpressionExtensions.cs" />
@@ -117,7 +117,7 @@
     <Compile Include="ILayout.cs" />
     <Compile Include="ILayoutDescriptor.cs" />
     <Compile Include="ILineBuilderFactory.cs" />
-    <Compile Include="ILineBulder.cs" />
+    <Compile Include="ILineBuilder.cs" />
     <Compile Include="ILineParser.cs" />
     <Compile Include="ILineParserFactory.cs" />
     <Compile Include="ITypeConverter.cs" />
diff --git a/src/FlatFile.Core/ILineBulder.cs b/src/FlatFile.Core/ILineBuilder.cs
similarity index 69%
rename from src/FlatFile.Core/ILineBulder.cs
rename to src/FlatFile.Core/ILineBuilder.cs
index 7d3e923..de3ca92 100644
--- a/src/FlatFile.Core/ILineBulder.cs
+++ b/src/FlatFile.Core/ILineBuilder.cs
@@ -1,6 +1,6 @@
 namespace FlatFile.Core
 {
-    public interface ILineBulder
+    public interface ILineBuilder
     {
         string BuildLine<T>(T entry);
     }
diff --git a/src/FlatFile.Core/ILineBuilderFactory.cs b/src/FlatFile.Core/ILineBuilderFactory.cs
index f2c561b..c649c0d 100644
--- a/src/FlatFile.Core/ILineBuilderFactory.cs
+++ b/src/FlatFile.Core/ILineBuilderFactory.cs
@@ -5,7 +5,7 @@ namespace FlatFile.Core
     public interface ILineBuilderFactory<out TBuilder, in TLayout, TFieldSettings>
         where TFieldSettings : IFieldSettings   
         where TLayout : ILayoutDescriptor<TFieldSettings>
-        where TBuilder : ILineBulder
+        where TBuilder : ILineBuilder
     {
         TBuilder GetBuilder(TLayout layout);
     }
diff --git a/src/FlatFile.Delimited/IDelimitedLineBuilder.cs b/src/FlatFile.Delimited/IDelimitedLineBuilder.cs
index 3d2cf7f..3c822d9 100644
--- a/src/FlatFile.Delimited/IDelimitedLineBuilder.cs
+++ b/src/FlatFile.Delimited/IDelimitedLineBuilder.cs
@@ -2,7 +2,7 @@
 {
     using FlatFile.Core;
 
-    public interface IDelimitedLineBuilder : ILineBulder
+    public interface IDelimitedLineBuilder : ILineBuilder
     {
     }
 }
\ No newline at end of file
diff --git a/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs b/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
index 215d974..bbf5f97 100644
--- a/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
@@ -79,7 +79,7 @@ internal DelimitedFileMultiEngine(
         /// <value>The line builder.</value>
         /// <remarks>The <see cref="DelimitedFileMultiEngine"/> does not contain just a single line builder.</remarks>
         /// <exception cref="System.NotImplementedException"></exception>
-        protected override ILineBulder LineBuilder { get { throw new NotImplementedException(); } }
+        protected override ILineBuilder LineBuilder { get { throw new NotImplementedException(); } }
 
         /// <summary>
         /// Gets the line parser.
diff --git a/src/FlatFile.Delimited/Implementation/DelimitedFileEngine.cs b/src/FlatFile.Delimited/Implementation/DelimitedFileEngine.cs
index cccbd39..6ee7a6b 100644
--- a/src/FlatFile.Delimited/Implementation/DelimitedFileEngine.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimitedFileEngine.cs
@@ -50,7 +50,7 @@ internal DelimitedFileEngine(
         /// Gets the line builder.
         /// </summary>
         /// <value>The line builder.</value>
-        protected override ILineBulder LineBuilder
+        protected override ILineBuilder LineBuilder
         {
             get { return _builderFactory.GetBuilder(LayoutDescriptor); }
         }
diff --git a/src/FlatFile.Delimited/Implementation/DelimitedLineBuilder.cs b/src/FlatFile.Delimited/Implementation/DelimitedLineBuilder.cs
index c7aaf02..e479c04 100644
--- a/src/FlatFile.Delimited/Implementation/DelimitedLineBuilder.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimitedLineBuilder.cs
@@ -4,7 +4,7 @@
     using FlatFile.Core.Base;
 
     public class DelimitedLineBuilder :
-        LineBulderBase<IDelimitedLayoutDescriptor, IDelimitedFieldSettingsContainer>, 
+        LineBuilderBase<IDelimitedLayoutDescriptor, IDelimitedFieldSettingsContainer>, 
         IDelimitedLineBuilder
     {
         public DelimitedLineBuilder(IDelimitedLayoutDescriptor descriptor)
diff --git a/src/FlatFile.FixedLength/IFixedLengthLineBuilder.cs b/src/FlatFile.FixedLength/IFixedLengthLineBuilder.cs
index 55927a3..d4e0fb4 100644
--- a/src/FlatFile.FixedLength/IFixedLengthLineBuilder.cs
+++ b/src/FlatFile.FixedLength/IFixedLengthLineBuilder.cs
@@ -2,7 +2,7 @@ namespace FlatFile.FixedLength
 {
     using FlatFile.Core;
 
-    public interface IFixedLengthLineBuilder : ILineBulder
+    public interface IFixedLengthLineBuilder : ILineBuilder
     {
     }
 }
\ No newline at end of file
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngine.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngine.cs
index 22686c9..786a710 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngine.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngine.cs
@@ -44,7 +44,7 @@ internal FixedLengthFileEngine(
         /// Gets the line builder.
         /// </summary>
         /// <value>The line builder.</value>
-        protected override ILineBulder LineBuilder
+        protected override ILineBuilder LineBuilder
         {
             get { return lineBuilderFactory.GetBuilder(LayoutDescriptor); }
         }
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
index 9226d09..013c2b5 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
@@ -79,7 +79,7 @@ internal FixedLengthFileMultiEngine(
         /// <value>The line builder.</value>
         /// <remarks>The <see cref="FixedLengthFileMultiEngine"/> does not contain just a single line builder.</remarks>
         /// <exception cref="System.NotImplementedException"></exception>
-        protected override ILineBulder LineBuilder { get { throw new NotImplementedException(); } }
+        protected override ILineBuilder LineBuilder { get { throw new NotImplementedException(); } }
 
         /// <summary>
         /// Gets the line parser.
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthLineBuilder.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthLineBuilder.cs
index 088ccc6..e49466d 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthLineBuilder.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthLineBuilder.cs
@@ -5,7 +5,7 @@ namespace FlatFile.FixedLength.Implementation
     using FlatFile.Core.Base;
 
     public class FixedLengthLineBuilder :
-        LineBulderBase<ILayoutDescriptor<IFixedFieldSettingsContainer>, IFixedFieldSettingsContainer>,
+        LineBuilderBase<ILayoutDescriptor<IFixedFieldSettingsContainer>, IFixedFieldSettingsContainer>,
         IFixedLengthLineBuilder
     {
         public FixedLengthLineBuilder(ILayoutDescriptor<IFixedFieldSettingsContainer> descriptor)

From 44df85ca5a3c6804c78be38b13ab67899c294d67 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Mon, 6 Aug 2018 21:44:18 -0500
Subject: [PATCH 09/17] Add PropertyInfo to ITypeConverter members.

---
 .../Converters/CsvHelperTypeConverterForCustomType.cs      | 4 ++--
 .../Converters/FlatFileTypeConverterForCustomType.cs       | 5 +++--
 src/FlatFile.Core/Base/LineParserBase.cs                   | 7 ++++---
 src/FlatFile.Core/ITypeConverter.cs                        | 5 +++--
 .../Delimited/DelimitedAttributeMappingIntegrationTests.cs | 2 +-
 5 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/FlatFile.Benchmark/Converters/CsvHelperTypeConverterForCustomType.cs b/src/FlatFile.Benchmark/Converters/CsvHelperTypeConverterForCustomType.cs
index 8f82fab..75ac847 100644
--- a/src/FlatFile.Benchmark/Converters/CsvHelperTypeConverterForCustomType.cs
+++ b/src/FlatFile.Benchmark/Converters/CsvHelperTypeConverterForCustomType.cs
@@ -14,12 +14,12 @@ public CsvHelperTypeConverterForCustomType()
 
         public string ConvertToString(CsvHelperTypeConversion.TypeConverterOptions options, object value)
         {
-            return converter.ConvertToString(value);
+            return converter.ConvertToString(value, null);
         }
 
         public object ConvertFromString(CsvHelperTypeConversion.TypeConverterOptions options, string text)
         {
-            return converter.ConvertFromString(text);
+            return converter.ConvertFromString(text, null);
         }
 
         public bool CanConvertFrom(Type type)
diff --git a/src/FlatFile.Benchmark/Converters/FlatFileTypeConverterForCustomType.cs b/src/FlatFile.Benchmark/Converters/FlatFileTypeConverterForCustomType.cs
index 148e297..3c6abcb 100644
--- a/src/FlatFile.Benchmark/Converters/FlatFileTypeConverterForCustomType.cs
+++ b/src/FlatFile.Benchmark/Converters/FlatFileTypeConverterForCustomType.cs
@@ -1,6 +1,7 @@
 namespace FlatFile.Benchmark.Converters
 {
     using System;
+    using System.Reflection;
     using FlatFile.Benchmark.Entities;
     using FlatFile.Core;
 
@@ -16,13 +17,13 @@ public bool CanConvertTo(Type type)
             return type == typeof (CustomType);
         }
 
-        public string ConvertToString(object source)
+        public string ConvertToString(object source, PropertyInfo sourceProperty)
         {
             var obj = (CustomType)source;
             return string.Format("{0}|{1}|{2}", obj.First, obj.Second, obj.Third);
         }
 
-        public object ConvertFromString(string source)
+        public object ConvertFromString(string source, PropertyInfo targetProperty)
         {
             var values = source.Split('|');
 
diff --git a/src/FlatFile.Core/Base/LineParserBase.cs b/src/FlatFile.Core/Base/LineParserBase.cs
index 9a802fc..78f2d16 100644
--- a/src/FlatFile.Core/Base/LineParserBase.cs
+++ b/src/FlatFile.Core/Base/LineParserBase.cs
@@ -1,6 +1,7 @@
 namespace FlatFile.Core.Base
 {
     using System;
+    using System.Reflection;
     using FlatFile.Core.Extensions;
 
     public abstract class LineParserBase<TLayoutDescriptor, TFieldSettings> : ILineParser
@@ -39,7 +40,7 @@ protected virtual object GetFieldValueFromString(TFieldSettings fieldSettings, s
 
             object obj;
             
-            if (!fieldSettings.TypeConverter.ConvertFromStringTo(memberValue, type, out obj))
+            if (!fieldSettings.TypeConverter.ConvertFromStringTo(memberValue, type, fieldSettings.PropertyInfo, out obj))
             {
                 obj = memberValue.Convert(type);
             }
@@ -56,11 +57,11 @@ protected virtual string TransformStringValue(TFieldSettings fieldSettingsBuilde
     public static class TypeConverterExtensions
     {
 
-        public static bool ConvertFromStringTo(this ITypeConverter converter, string source, Type targetType, out object obj)
+        public static bool ConvertFromStringTo(this ITypeConverter converter, string source, Type targetType, PropertyInfo targetProperty, out object obj)
         {
             if (converter != null && converter.CanConvertFrom(typeof(string)) && converter.CanConvertTo(targetType))
             {
-                obj = converter.ConvertFromString(source);
+                obj = converter.ConvertFromString(source, targetProperty);
                 return true;
             }
 
diff --git a/src/FlatFile.Core/ITypeConverter.cs b/src/FlatFile.Core/ITypeConverter.cs
index f199ea8..06b7143 100644
--- a/src/FlatFile.Core/ITypeConverter.cs
+++ b/src/FlatFile.Core/ITypeConverter.cs
@@ -1,6 +1,7 @@
 namespace FlatFile.Core
 {
     using System;
+    using System.Reflection;
 
     public interface ITypeConverter
     {
@@ -8,8 +9,8 @@ public interface ITypeConverter
 
         bool CanConvertTo(Type type);
 
-        string ConvertToString(object source);
+        string ConvertToString(object source, PropertyInfo sourceProperty);
 
-        object ConvertFromString(string source);
+        object ConvertFromString(string source, PropertyInfo targetProperty);
     }
 }
\ No newline at end of file
diff --git a/src/FlatFile.Tests/Delimited/DelimitedAttributeMappingIntegrationTests.cs b/src/FlatFile.Tests/Delimited/DelimitedAttributeMappingIntegrationTests.cs
index 03b2626..70376e9 100644
--- a/src/FlatFile.Tests/Delimited/DelimitedAttributeMappingIntegrationTests.cs
+++ b/src/FlatFile.Tests/Delimited/DelimitedAttributeMappingIntegrationTests.cs
@@ -36,7 +36,7 @@ public void EngineShouldCallTypeConverterWhenConverterAttributeIsPresent()
 		{
 			// a converter to convert "A" to "foo"
 			var converter = A.Fake<ITypeConverter>();
-			A.CallTo(() => converter.ConvertFromString("A")).Returns("foo");
+			A.CallTo(() => converter.ConvertFromString("A", A<PropertyInfo>.Ignored)).Returns("foo");
 			A.CallTo(() => converter.CanConvertFrom(typeof(string))).Returns(true);
 			A.CallTo(() => converter.CanConvertTo(typeof(string))).Returns(true);
 

From b9563c471509d60d875c3a9ace0cf8188eeb8a1d Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Mon, 6 Aug 2018 21:44:52 -0500
Subject: [PATCH 10/17] Use type converter when building lines.

---
 src/FlatFile.Core/Base/LineBuilderBase.cs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/FlatFile.Core/Base/LineBuilderBase.cs b/src/FlatFile.Core/Base/LineBuilderBase.cs
index 8a6797e..234b12e 100644
--- a/src/FlatFile.Core/Base/LineBuilderBase.cs
+++ b/src/FlatFile.Core/Base/LineBuilderBase.cs
@@ -21,7 +21,7 @@ protected TLayoutDescriptor Descriptor
         protected virtual string GetStringValueFromField(TFieldSettings field, object fieldValue)
         {
             string lineValue = fieldValue != null
-                ? fieldValue.ToString()
+                ? ConvertToString(field, fieldValue)
                 : field.NullValue ?? string.Empty;
 
             lineValue = TransformFieldValue(field, lineValue);
@@ -33,5 +33,14 @@ protected virtual string TransformFieldValue(TFieldSettings field, string lineVa
         {
             return lineValue;
         }
+
+        private static string ConvertToString(TFieldSettings field, object fieldValue)
+        {
+            var converter = field.TypeConverter;
+            if (converter != null && converter.CanConvertTo(typeof(string)) && converter.CanConvertFrom(field.PropertyInfo.PropertyType))
+                return field.TypeConverter.ConvertToString(fieldValue, field.PropertyInfo);
+
+            return fieldValue.ToString();
+        }
     }
 }
\ No newline at end of file

From e858c039157a2605984d1af1a5186435f575c4e9 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Tue, 7 Aug 2018 01:23:06 -0500
Subject: [PATCH 11/17] Implement field settings builder methods that take
 lambdas. Also add tests and the xunit Visual Studio runner.

---
 src/FlatFile.Core/Base/TypeConverterBase.cs   | 36 ++++++++++
 src/FlatFile.Core/DelegatingTypeConverter.cs  | 37 ++++++++++
 src/FlatFile.Core/FlatFile.Core.csproj        |  2 +
 .../IFieldSettingsConstructor.cs              |  3 +
 .../DelimitedFieldSettingsConstructor.cs      | 27 ++++++++
 .../FixedFieldSettingsConstructor.cs          | 26 +++++++
 .../Delimited/DelimitedLineBuilderTests.cs    | 68 +++++++++++++++++++
 .../Delimited/DelimitedLineParserTests.cs     | 60 ++++++++++++++++
 .../FixedLengthLineBuilderTests.cs            | 68 +++++++++++++++++++
 .../FixedLength/FixedLengthLineParserTests.cs | 43 ++++++++++++
 src/FlatFile.Tests/FlatFile.Tests.csproj      | 12 ++++
 src/FlatFile.Tests/packages.config            |  1 +
 12 files changed, 383 insertions(+)
 create mode 100644 src/FlatFile.Core/Base/TypeConverterBase.cs
 create mode 100644 src/FlatFile.Core/DelegatingTypeConverter.cs
 create mode 100644 src/FlatFile.Tests/Delimited/DelimitedLineBuilderTests.cs
 create mode 100644 src/FlatFile.Tests/Delimited/DelimitedLineParserTests.cs
 create mode 100644 src/FlatFile.Tests/FixedLength/FixedLengthLineBuilderTests.cs

diff --git a/src/FlatFile.Core/Base/TypeConverterBase.cs b/src/FlatFile.Core/Base/TypeConverterBase.cs
new file mode 100644
index 0000000..9bf82bb
--- /dev/null
+++ b/src/FlatFile.Core/Base/TypeConverterBase.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Reflection;
+
+namespace FlatFile.Core.Base
+{
+    /// <summary>
+    /// A generic base class for converting between strings and a given type.
+    /// </summary>
+    /// <typeparam name="TValue">The type to convert to and from a string.</typeparam>
+    public abstract class TypeConverterBase<TValue> : ITypeConverter
+    {
+        public virtual bool CanConvertFrom(Type type)
+        {
+            return type == typeof(string) || type == typeof(TValue);
+        }
+
+        public virtual bool CanConvertTo(Type type)
+        {
+            return type == typeof(string) || type == typeof(TValue);
+        }
+
+        public object ConvertFromString(string source, PropertyInfo targetProperty)
+        {
+            return ConvertFrom(source, targetProperty);
+        }
+
+        protected abstract TValue ConvertFrom(string source, PropertyInfo targetProperty);
+
+        public string ConvertToString(object source, PropertyInfo sourceProperty)
+        {
+            return ConvertTo((TValue)source, sourceProperty);
+        }
+
+        protected abstract string ConvertTo(TValue source, PropertyInfo sourceProperty);
+    }
+}
diff --git a/src/FlatFile.Core/DelegatingTypeConverter.cs b/src/FlatFile.Core/DelegatingTypeConverter.cs
new file mode 100644
index 0000000..f991a77
--- /dev/null
+++ b/src/FlatFile.Core/DelegatingTypeConverter.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Reflection;
+
+namespace FlatFile.Core
+{
+    /// <summary>
+    /// An implementation of <see cref="ITypeConverter"/> that uses delegates for conversion.
+    /// </summary>
+    class DelegatingTypeConverter<TProperty> : ITypeConverter
+    {
+        internal Func<string, TProperty> ConversionFromString { get; set; }
+
+        internal Func<TProperty, string> ConversionToString { get; set; }
+
+        public bool CanConvertFrom(Type type)
+        {
+            return (type == typeof(string) && ConversionFromString != null) ||
+                   (type == typeof(TProperty) && ConversionToString != null);
+        }
+
+        public bool CanConvertTo(Type type)
+        {
+            return (type == typeof(string) && ConversionToString != null) ||
+                   (type == typeof(TProperty) && ConversionFromString != null);
+        }
+
+        public object ConvertFromString(string source, PropertyInfo targetProperty)
+        {
+            return ConversionFromString(source);
+        }
+
+        public string ConvertToString(object source, PropertyInfo sourceProperty)
+        {
+            return ConversionToString((TProperty)source);
+        }
+    }
+}
diff --git a/src/FlatFile.Core/FlatFile.Core.csproj b/src/FlatFile.Core/FlatFile.Core.csproj
index d20d4cf..052a837 100644
--- a/src/FlatFile.Core/FlatFile.Core.csproj
+++ b/src/FlatFile.Core/FlatFile.Core.csproj
@@ -102,6 +102,8 @@
     <Compile Include="Base\LayoutDescriptorBase.cs" />
     <Compile Include="Base\LineBuilderBase.cs" />
     <Compile Include="Base\LineParserBase.cs" />
+    <Compile Include="Base\TypeConverterBase.cs" />
+    <Compile Include="DelegatingTypeConverter.cs" />
     <Compile Include="Exceptions\ParseLineException.cs" />
     <Compile Include="Extensions\ExpressionExtensions.cs" />
     <Compile Include="Extensions\FieldsSettingsExtensions.cs" />
diff --git a/src/FlatFile.Core/IFieldSettingsConstructor.cs b/src/FlatFile.Core/IFieldSettingsConstructor.cs
index 4acca7e..45e63c7 100644
--- a/src/FlatFile.Core/IFieldSettingsConstructor.cs
+++ b/src/FlatFile.Core/IFieldSettingsConstructor.cs
@@ -1,11 +1,14 @@
 namespace FlatFile.Core
 {
     using FlatFile.Core.Base;
+    using System;
 
     public interface IFieldSettingsConstructor<out TConstructor> : IFieldSettingsContainer
         where TConstructor : IFieldSettingsConstructor<TConstructor>
     {
         TConstructor AllowNull(string nullValue);
         TConstructor WithTypeConverter<TConverter>() where TConverter : ITypeConverter;
+        TConstructor WithConversionFromString<TProperty>(Func<string, TProperty> conversion);
+        TConstructor WithConversionToString<TProperty>(Func<TProperty, string> conversion);
     }
 }
\ No newline at end of file
diff --git a/src/FlatFile.Delimited/Implementation/DelimitedFieldSettingsConstructor.cs b/src/FlatFile.Delimited/Implementation/DelimitedFieldSettingsConstructor.cs
index 2124a0f..8f3cdbc 100644
--- a/src/FlatFile.Delimited/Implementation/DelimitedFieldSettingsConstructor.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimitedFieldSettingsConstructor.cs
@@ -1,5 +1,6 @@
 namespace FlatFile.Delimited.Implementation
 {
+    using System;
     using System.Reflection;
     using FlatFile.Core;
     using FlatFile.Core.Extensions;
@@ -25,6 +26,32 @@ public IDelimitedFieldSettingsConstructor WithTypeConverter<TConverter>() where
             return this;
         }
 
+        public IDelimitedFieldSettingsConstructor WithConversionFromString<TProperty>(Func<string, TProperty> conversion)
+        {
+            if (TypeConverter == null)
+                TypeConverter = new DelegatingTypeConverter<TProperty>();
+
+            if (TypeConverter is DelegatingTypeConverter<TProperty>)
+                ((DelegatingTypeConverter<TProperty>)TypeConverter).ConversionFromString = conversion;
+            else
+                throw new InvalidOperationException("A type converter has already been explicitly set.");
+
+            return this;
+        }
+
+        public IDelimitedFieldSettingsConstructor WithConversionToString<TProperty>(Func<TProperty, string> conversion)
+        {
+            if (TypeConverter == null)
+                TypeConverter = new DelegatingTypeConverter<TProperty>();
+
+            if (TypeConverter is DelegatingTypeConverter<TProperty>)
+                ((DelegatingTypeConverter<TProperty>)TypeConverter).ConversionToString = conversion;
+            else
+                throw new InvalidOperationException("A type converter has already been explicitly set.");
+
+            return this;
+        }
+
         public IDelimitedFieldSettingsConstructor WithName(string name)
         {
             Name = name;
diff --git a/src/FlatFile.FixedLength/Implementation/FixedFieldSettingsConstructor.cs b/src/FlatFile.FixedLength/Implementation/FixedFieldSettingsConstructor.cs
index e8683be..4ea46fb 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedFieldSettingsConstructor.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedFieldSettingsConstructor.cs
@@ -57,5 +57,31 @@ public IFixedFieldSettingsConstructor WithTypeConverter<TConverter>() where TCon
             this.TypeConverter = ReflectionHelper.CreateInstance<TConverter>(true);
             return this;
         }
+
+        public IFixedFieldSettingsConstructor WithConversionFromString<TProperty>(Func<string, TProperty> conversion)
+        {
+            if (TypeConverter == null)
+                TypeConverter = new DelegatingTypeConverter<TProperty>();
+
+            if (TypeConverter is DelegatingTypeConverter<TProperty>)
+                ((DelegatingTypeConverter<TProperty>)TypeConverter).ConversionFromString = conversion;
+            else
+                throw new InvalidOperationException("A type converter has already been explicitly set.");
+
+            return this;
+        }
+
+        public IFixedFieldSettingsConstructor WithConversionToString<TProperty>(Func<TProperty, string> conversion)
+        {
+            if (TypeConverter == null)
+                TypeConverter = new DelegatingTypeConverter<TProperty>();
+
+            if (TypeConverter is DelegatingTypeConverter<TProperty>)
+                ((DelegatingTypeConverter<TProperty>)TypeConverter).ConversionToString = conversion;
+            else
+                throw new InvalidOperationException("A type converter has already been explicitly set.");
+
+            return this;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/FlatFile.Tests/Delimited/DelimitedLineBuilderTests.cs b/src/FlatFile.Tests/Delimited/DelimitedLineBuilderTests.cs
new file mode 100644
index 0000000..6e8ddc0
--- /dev/null
+++ b/src/FlatFile.Tests/Delimited/DelimitedLineBuilderTests.cs
@@ -0,0 +1,68 @@
+namespace FlatFile.Tests.Delimited
+{
+    using FlatFile.Core.Base;
+    using FlatFile.Delimited;
+    using FlatFile.Delimited.Implementation;
+    using FlatFile.Tests.Base.Entities;
+    using FluentAssertions;
+    using System;
+    using System.Globalization;
+    using System.Reflection;
+    using Xunit;
+
+    public class DelimitedLineBuilderTests
+    {
+        private readonly DelimitedLineBuilder builder;
+        private readonly IDelimitedLayout<TestObject> layout;
+
+        public DelimitedLineBuilderTests()
+        {
+            layout = new DelimitedLayout<TestObject>().WithDelimiter(",");
+
+            builder = new DelimitedLineBuilder(layout);
+        }
+
+        [Fact]
+        public void BuilderShouldUseTypeConverter()
+        {
+            layout.WithMember(o => o.Id, set => set.WithTypeConverter<IdHexConverter>());
+
+            var entry = new TestObject
+            {
+                Id = 48879
+            };
+
+            var line = builder.BuildLine(entry);
+
+            line.Should().Be("BEEF");
+        }
+
+        [Fact]
+        public void BuilderShouldUseConversionFunction()
+        {
+            layout.WithMember(o => o.Id, set => set.WithConversionToString((int id) => id.ToString("X")));
+
+            var entry = new TestObject
+            {
+                Id = 48879
+            };
+
+            var line = builder.BuildLine(entry);
+
+            line.Should().Be("BEEF");
+        }
+
+        class IdHexConverter : TypeConverterBase<int>
+        {
+            protected override int ConvertFrom(string source, PropertyInfo targetProperty)
+            {
+                return Int32.Parse(source, NumberStyles.AllowHexSpecifier);
+            }
+
+            protected override string ConvertTo(int source, PropertyInfo sourceProperty)
+            {
+                return source.ToString("X");
+            }
+        }
+    }
+}
diff --git a/src/FlatFile.Tests/Delimited/DelimitedLineParserTests.cs b/src/FlatFile.Tests/Delimited/DelimitedLineParserTests.cs
new file mode 100644
index 0000000..04f7669
--- /dev/null
+++ b/src/FlatFile.Tests/Delimited/DelimitedLineParserTests.cs
@@ -0,0 +1,60 @@
+namespace FlatFile.Tests.Delimited
+{
+    using FlatFile.Core.Base;
+    using FlatFile.Delimited;
+    using FlatFile.Delimited.Implementation;
+    using FlatFile.Tests.Base.Entities;
+    using FluentAssertions;
+    using System;
+    using System.Globalization;
+    using System.Reflection;
+    using Xunit;
+
+    public class DelimitedLineParserTests
+    {
+        private readonly DelimitedLineParser parser;
+        private readonly IDelimitedLayout<TestObject> layout;
+
+        public DelimitedLineParserTests()
+        {
+            layout = new DelimitedLayout<TestObject>().WithDelimiter(",");
+
+            parser = new DelimitedLineParser(layout);
+        }
+
+        [Fact]
+        public void ParserShouldUseTypeConverter()
+        {
+            layout.WithMember(o => o.Id, set => set.WithTypeConverter<IdHexConverter>());
+
+            var entry = new TestObject();
+            var parsedEntity = parser.ParseLine("BEEF", entry);
+
+            parsedEntity.Id.Should().Be(48879);
+        }
+
+        [Fact]
+        public void ParserShouldUseConversionFunction()
+        {
+            layout.WithMember(o => o.Id, set => set.WithConversionFromString(s => Int32.Parse(s, NumberStyles.AllowHexSpecifier)));
+
+            var entry = new TestObject();
+            var parsedEntity = parser.ParseLine("BEEF", entry);
+
+            parsedEntity.Id.Should().Be(48879);
+        }
+
+        class IdHexConverter : TypeConverterBase<int>
+        {
+            protected override int ConvertFrom(string source, PropertyInfo targetProperty)
+            {
+                return Int32.Parse(source, NumberStyles.AllowHexSpecifier);
+            }
+
+            protected override string ConvertTo(int source, PropertyInfo sourceProperty)
+            {
+                return source.ToString("X");
+            }
+        }
+    }
+}
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthLineBuilderTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthLineBuilderTests.cs
new file mode 100644
index 0000000..6609035
--- /dev/null
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthLineBuilderTests.cs
@@ -0,0 +1,68 @@
+namespace FlatFile.Tests.FixedLength
+{
+    using FlatFile.Core.Base;
+    using FlatFile.FixedLength;
+    using FlatFile.FixedLength.Implementation;
+    using FlatFile.Tests.Base.Entities;
+    using FluentAssertions;
+    using System;
+    using System.Globalization;
+    using System.Reflection;
+    using Xunit;
+
+    public class FixedLengthLineBuilderTests
+    {
+        private readonly FixedLengthLineBuilder builder;
+        private readonly IFixedLayout<TestObject> layout;
+
+        public FixedLengthLineBuilderTests()
+        {
+            layout = new FixedLayout<TestObject>();
+
+            builder = new FixedLengthLineBuilder(layout);
+        }
+
+        [Fact]
+        public void BuilderShouldUseTypeConverter()
+        {
+            layout.WithMember(o => o.Id, set => set.WithLength(4).WithTypeConverter<IdHexConverter>());
+
+            var entry = new TestObject
+            {
+                Id = 48879
+            };
+
+            var line = builder.BuildLine(entry);
+
+            line.Should().Be("BEEF");
+        }
+
+        [Fact]
+        public void BuilderShouldUseConversionFunction()
+        {
+            layout.WithMember(o => o.Id, set => set.WithLength(4).WithConversionToString((int id) => id.ToString("X")));
+
+            var entry = new TestObject
+            {
+                Id = 48879
+            };
+
+            var line = builder.BuildLine(entry);
+
+            line.Should().Be("BEEF");
+        }
+
+        class IdHexConverter : TypeConverterBase<int>
+        {
+            protected override int ConvertFrom(string source, PropertyInfo targetProperty)
+            {
+                return Int32.Parse(source, NumberStyles.AllowHexSpecifier);
+            }
+
+            protected override string ConvertTo(int source, PropertyInfo sourceProperty)
+            {
+                return source.ToString("X");
+            }
+        }
+    }
+}
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthLineParserTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthLineParserTests.cs
index a047bb7..bea64aa 100644
--- a/src/FlatFile.Tests/FixedLength/FixedLengthLineParserTests.cs
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthLineParserTests.cs
@@ -2,10 +2,14 @@
 
 namespace FlatFile.Tests.FixedLength
 {
+    using FlatFile.Core.Base;
     using FlatFile.FixedLength;
     using FlatFile.FixedLength.Implementation;
     using FlatFile.Tests.Base.Entities;
     using FluentAssertions;
+    using System;
+    using System.Globalization;
+    using System.Reflection;
 
     public class FixedLengthLineParserTests
     {
@@ -50,5 +54,44 @@ public void ParserShouldSetValueNullValueIfStringIsToShort(string inputString, i
             parsedEntity.Description.Should().Be(description);
             parsedEntity.NullableInt.Should().Be(nullableInt);
         }
+
+        [Fact]
+        public void ParserShouldUseTypeConverter()
+        {
+            layout.WithMember(o => o.Id, set => set.WithLength(4).WithTypeConverter<IdHexConverter>())
+                  .WithMember(o => o.Description, set => set.WithLength(25).AllowNull(string.Empty))
+                  .WithMember(o => o.NullableInt, set => set.WithLength(5).AllowNull(string.Empty));
+
+            var entry = new TestObject();
+            var parsedEntity = parser.ParseLine("BEEF", entry);
+
+            parsedEntity.Id.Should().Be(48879);
+        }
+
+        [Fact]
+        public void ParserShouldUseConversionFunction()
+        {
+            layout.WithMember(o => o.Id, set => set.WithLength(4).WithConversionFromString(s => Int32.Parse(s, NumberStyles.AllowHexSpecifier)))
+                  .WithMember(o => o.Description, set => set.WithLength(25).AllowNull(string.Empty))
+                  .WithMember(o => o.NullableInt, set => set.WithLength(5).AllowNull(string.Empty));
+
+            var entry = new TestObject();
+            var parsedEntity = parser.ParseLine("BEEF", entry);
+
+            parsedEntity.Id.Should().Be(48879);
+        }
+
+        class IdHexConverter : TypeConverterBase<int>
+        {
+            protected override int ConvertFrom(string source, PropertyInfo targetProperty)
+            {
+                return Int32.Parse(source, NumberStyles.AllowHexSpecifier);
+            }
+
+            protected override string ConvertTo(int source, PropertyInfo sourceProperty)
+            {
+                return source.ToString("X");
+            }
+        }
     }
 }
diff --git a/src/FlatFile.Tests/FlatFile.Tests.csproj b/src/FlatFile.Tests/FlatFile.Tests.csproj
index 57f98f9..b4cc6c8 100644
--- a/src/FlatFile.Tests/FlatFile.Tests.csproj
+++ b/src/FlatFile.Tests/FlatFile.Tests.csproj
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props" Condition="Exists('..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props')" />
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -13,6 +14,8 @@
     <FileAlignment>512</FileAlignment>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -79,11 +82,14 @@
     <Compile Include="Delimited\DelimitedAttributeMappingIntegrationTests.cs" />
     <Compile Include="Delimited\DelimitedIntegrationTests.cs" />
     <Compile Include="Delimited\DelimitedLayoutTests.cs" />
+    <Compile Include="Delimited\DelimitedLineBuilderTests.cs" />
+    <Compile Include="Delimited\DelimitedLineParserTests.cs" />
     <Compile Include="Delimited\DelimitedMultiEngineTests.cs" />
     <Compile Include="Delimited\DelimitedWithHeaderIntegrationTests.cs" />
     <Compile Include="FixedLength\FixedLayoutTests.cs" />
     <Compile Include="FixedLength\FixedLengthAttributeMappingIntegrationTests.cs" />
     <Compile Include="FixedLength\FixedLengthIntegrationTests.cs" />
+    <Compile Include="FixedLength\FixedLengthLineBuilderTests.cs" />
     <Compile Include="FixedLength\FixedLengthLineParserTests.cs" />
     <Compile Include="FixedLength\FixedLengthMasterDetailTests.cs" />
     <Compile Include="FixedLength\FixedLengthMultiEngineTests.cs" />
@@ -138,6 +144,12 @@
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props'))" />
+  </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/src/FlatFile.Tests/packages.config b/src/FlatFile.Tests/packages.config
index 0f982a6..1357199 100644
--- a/src/FlatFile.Tests/packages.config
+++ b/src/FlatFile.Tests/packages.config
@@ -11,4 +11,5 @@
   <package id="xunit.extensibility.core" version="2.1.0" targetFramework="net45" />
   <package id="xunit.extensibility.execution" version="2.1.0" targetFramework="net45" />
   <package id="xunit.runner.console" version="2.1.0" targetFramework="net45" />
+  <package id="xunit.runner.visualstudio" version="2.1.0" targetFramework="net45" />
 </packages>
\ No newline at end of file

From 3a9d4c4b286780029c5f67fc6096e9ffa203ebf1 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Tue, 7 Aug 2018 18:58:14 -0500
Subject: [PATCH 12/17] Add gitignore file to solution.

---
 src/FlatFile.sln | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/FlatFile.sln b/src/FlatFile.sln
index 5d34875..475f513 100644
--- a/src/FlatFile.sln
+++ b/src/FlatFile.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25420.1
+# Visual Studio 15
+VisualStudioVersion = 15.0.27703.2000
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FlatFile.Core", "FlatFile.Core\FlatFile.Core.csproj", "{1CB90052-B97A-4AD4-B9FD-20A22914D129}"
 EndProject
@@ -9,6 +9,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FlatFile.FixedLength", "Fla
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "assets", "assets", "{874AF755-A91B-434F-9679-35BEBC8B7D9F}"
 	ProjectSection(SolutionItems) = preProject
+		..\.gitignore = ..\.gitignore
 		..\appveyor.yml = ..\appveyor.yml
 		..\nuspecs\FlatFile.Core.Attributes.nuspec = ..\nuspecs\FlatFile.Core.Attributes.nuspec
 		..\nuspecs\FlatFile.Core.nuspec = ..\nuspecs\FlatFile.Core.nuspec
@@ -79,4 +80,7 @@ Global
 		{1484D999-2EC8-4D73-ACCC-17E25F98E20F} = {58C25CA0-7F53-46A6-873E-1E1B18D65222}
 		{7B8FE44C-7725-40C2-AED4-7573F5ABAAB7} = {58C25CA0-7F53-46A6-873E-1E1B18D65222}
 	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {1CDB73F9-C29E-473D-96C3-D0FA67CCCF42}
+	EndGlobalSection
 EndGlobal

From ff863f5a8a2bc8999ab010cd081bf983ebe552d7 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Tue, 7 Aug 2018 18:58:31 -0500
Subject: [PATCH 13/17] Ignore .vs directory.

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index 6feb516..b36df8f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -157,3 +157,5 @@ $RECYCLE.BIN/
 assets/FlatFile.Core.Compiled.nuspec
 assets/FlatFile.Delimited.Compiled.nuspec
 assets/FlatFile.FixedLength.Compiled.nuspec
+
+.vs/
\ No newline at end of file

From 0b13e436af07a14b255bed82254fad1ea8fe19ac Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Fri, 10 Aug 2018 23:51:50 -0500
Subject: [PATCH 14/17] Expose TextReader and TextWriter methods for reading
 and writing files.

---
 src/FlatFile.Core/Base/FlatFileEngine.cs      | 26 +++++++++++++++++--
 src/FlatFile.Core/IFlatFileEngine.cs          | 16 ++++++++++++
 src/FlatFile.Core/IFlatFileMultiEngine.cs     |  8 ++++++
 .../DelimetedFileMultiEngine.cs               | 11 +++++++-
 .../FixedLengthFileMultiEngine.cs             | 12 ++++-----
 5 files changed, 64 insertions(+), 9 deletions(-)

diff --git a/src/FlatFile.Core/Base/FlatFileEngine.cs b/src/FlatFile.Core/Base/FlatFileEngine.cs
index 22d18a3..a3488b9 100644
--- a/src/FlatFile.Core/Base/FlatFileEngine.cs
+++ b/src/FlatFile.Core/Base/FlatFileEngine.cs
@@ -57,6 +57,18 @@ protected FlatFileEngine(Func<string, Exception, bool> handleEntryReadError = nu
         public virtual IEnumerable<TEntity> Read<TEntity>(Stream stream) where TEntity : class, new()
         {
             var reader = new StreamReader(stream);
+            return Read<TEntity>(reader);
+        }
+
+        /// <summary>
+        /// Reads the specified text reader.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the t entity.</typeparam>
+        /// <param name="reader">The reader.</param>
+        /// <returns>IEnumerable&lt;TEntity&gt;.</returns>
+        /// <exception cref="ParseLineException">Impossible to parse line</exception>
+        public virtual IEnumerable<TEntity> Read<TEntity>(TextReader reader) where TEntity : class, new()
+        {
             string line;
             int lineNumber = 0;
 
@@ -68,7 +80,7 @@ protected FlatFileEngine(Func<string, Exception, bool> handleEntryReadError = nu
             while ((line = reader.ReadLine()) != null)
             {
                 if (string.IsNullOrEmpty(line) || string.IsNullOrEmpty(line.Trim())) continue;
-                
+
                 bool ignoreEntry = false;
                 var entry = new TEntity();
                 try
@@ -104,7 +116,7 @@ protected FlatFileEngine(Func<string, Exception, bool> handleEntryReadError = nu
         /// Processes the header.
         /// </summary>
         /// <param name="reader">The reader.</param>
-        protected virtual void ProcessHeader(StreamReader reader)
+        protected virtual void ProcessHeader(TextReader reader)
         {
             reader.ReadLine();
         }
@@ -147,7 +159,17 @@ protected virtual void WriteEntry<TEntity>(TextWriter writer, int lineNumber, TE
         public virtual void Write<TEntity>(Stream stream, IEnumerable<TEntity> entries) where TEntity : class, new()
         {
             TextWriter writer = new StreamWriter(stream);
+            Write(writer, entries);
+        }
 
+        /// <summary>
+        /// Writes to the specified text writer.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the t entity.</typeparam>
+        /// <param name="stream">The text writer.</param>
+        /// <param name="entries">The entries.</param>
+        public void Write<TEntity>(TextWriter writer, IEnumerable<TEntity> entries) where TEntity : class, new()
+        {
             this.WriteHeader(writer);
 
             int lineNumber = 0;
diff --git a/src/FlatFile.Core/IFlatFileEngine.cs b/src/FlatFile.Core/IFlatFileEngine.cs
index 05a6d0f..b0b8a48 100644
--- a/src/FlatFile.Core/IFlatFileEngine.cs
+++ b/src/FlatFile.Core/IFlatFileEngine.cs
@@ -16,6 +16,14 @@ public interface IFlatFileEngine
         /// <returns>IEnumerable&lt;TEntity&gt;.</returns>
         IEnumerable<TEntity> Read<TEntity>(Stream stream) where TEntity : class, new();
 
+        /// <summary>
+        /// Reads from the specified text reader.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the t entity.</typeparam>
+        /// <param name="stream">The text reader.</param>
+        /// <returns>IEnumerable&lt;TEntity&gt;.</returns>
+        IEnumerable<TEntity> Read<TEntity>(TextReader reader) where TEntity : class, new();
+
         /// <summary>
         /// Writes to the specified stream.
         /// </summary>
@@ -23,5 +31,13 @@ public interface IFlatFileEngine
         /// <param name="stream">The stream.</param>
         /// <param name="entries">The entries.</param>
         void Write<TEntity>(Stream stream, IEnumerable<TEntity> entries) where TEntity : class, new();
+
+        /// <summary>
+        /// Writes to the specified text writer.
+        /// </summary>
+        /// <typeparam name="TEntity">The type of the t entity.</typeparam>
+        /// <param name="writer">The text writer.</param>
+        /// <param name="entries">The entries.</param>
+        void Write<TEntity>(TextWriter writer, IEnumerable<TEntity> entries) where TEntity : class, new();
     }
 }
\ No newline at end of file
diff --git a/src/FlatFile.Core/IFlatFileMultiEngine.cs b/src/FlatFile.Core/IFlatFileMultiEngine.cs
index a47b36d..c33299d 100644
--- a/src/FlatFile.Core/IFlatFileMultiEngine.cs
+++ b/src/FlatFile.Core/IFlatFileMultiEngine.cs
@@ -13,12 +13,20 @@ public interface IFlatFileMultiEngine : IFlatFileEngine
         /// </summary>
         /// <param name="stream">The stream.</param>
         void Read(Stream stream);
+
+        /// <summary>
+        /// Reads the specified text reader.
+        /// </summary>
+        /// <param name="stream">The text reader.</param>
+        void Read(TextReader reader);
+
         /// <summary>
         /// Gets any records of type <typeparamref name="T"/> read by <see cref="Read"/>.
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <returns>IEnumerable&lt;T&gt;.</returns>
         IEnumerable<T> GetRecords<T>() where T : class, new();
+
         /// <summary>
         /// Gets or sets a value indicating whether this instance has a file header.
         /// </summary>
diff --git a/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs b/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
index 215d974..5145be4 100644
--- a/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
@@ -137,7 +137,16 @@ protected override bool TryParseLine<TEntity>(string line, int lineNumber, ref T
         /// <exception cref="ParseLineException">Impossible to parse line</exception>
         public void Read(Stream stream)
         {
-            var reader = new StreamReader(stream);
+            Read(new StreamReader(stream));
+        }
+
+        /// <summary>
+        /// Reads the specified text reader.
+        /// </summary>
+        /// <param name="stream">The text reader.</param>
+        /// <exception cref="ParseLineException">Impossible to parse line</exception>
+        public void Read(TextReader reader)
+        {
             string line;
             var lineNumber = 0;
 
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
index 9226d09..9021c69 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
@@ -142,22 +142,22 @@ public void Read(Stream stream)
         }
 
         /// <summary>
-        /// Reads the specified streamReader.
+        /// Reads the specified text reader.
         /// </summary>
-        /// <param name="reader">The stream reader configured as the user wants.</param>
+        /// <param name="reader">The text reader configured as the user wants.</param>
         /// <exception cref="ParseLineException">Impossible to parse line</exception>
-        public void Read(StreamReader reader)
+        public void Read(TextReader reader)
         {
             ReadInternal(reader);
         }
 
         /// <summary>
-        /// Internal method (private) to read from streamreader instead of stream
+        /// Internal method (private) to read from a text reader instead of stream
         /// This way the client code have a way to specify encoding.
         /// </summary>
-        /// <param name="reader">The stream reader to read.</param>
+        /// <param name="reader">The text reader to read.</param>
         /// <exception cref="ParseLineException">Impossible to parse line</exception>
-        private void ReadInternal(StreamReader reader)
+        private void ReadInternal(TextReader reader)
         {
             string line;
             var lineNumber = 0;

From 8211a14249911e2b8b0925ac83acc461f69c40f4 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Sat, 11 Aug 2018 00:06:33 -0500
Subject: [PATCH 15/17] Update comments.

---
 .../Implementation/DelimetedFileMultiEngine.cs                  | 2 +-
 .../Implementation/FixedLengthFileMultiEngine.cs                | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs b/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
index 5145be4..e5b45db 100644
--- a/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimetedFileMultiEngine.cs
@@ -141,7 +141,7 @@ public void Read(Stream stream)
         }
 
         /// <summary>
-        /// Reads the specified text reader.
+        /// Reads from the specified text reader.
         /// </summary>
         /// <param name="stream">The text reader.</param>
         /// <exception cref="ParseLineException">Impossible to parse line</exception>
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
index 9021c69..499bfe5 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
@@ -142,7 +142,7 @@ public void Read(Stream stream)
         }
 
         /// <summary>
-        /// Reads the specified text reader.
+        /// Reads from the specified text reader.
         /// </summary>
         /// <param name="reader">The text reader configured as the user wants.</param>
         /// <exception cref="ParseLineException">Impossible to parse line</exception>

From b77b30c7483f0b504d590661b2618da8eab96f4f Mon Sep 17 00:00:00 2001
From: mthamil <matthamilton@live.com>
Date: Wed, 15 Aug 2018 20:47:41 -0500
Subject: [PATCH 16/17] Add contributor to license.

---
 LICENSE | 1 +
 1 file changed, 1 insertion(+)

diff --git a/LICENSE b/LICENSE
index 057e902..4369777 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,5 +1,6 @@
 The MIT License (MIT)
 
+Copyright (c) 2018 Matt Hamilton
 Copyright (c) 2014 Pavel Nosovich
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

From d7cad9b2d629b9efe2d43de379352c7b0cc257f0 Mon Sep 17 00:00:00 2001
From: Matthew Hamilton <matthamilton@live.com>
Date: Wed, 15 Aug 2018 23:38:34 -0500
Subject: [PATCH 17/17] Fix merge errors.

---
 .../Implementation/DelimitedFileEngineFactory.cs             | 5 ++++-
 .../Implementation/FixedLengthFileEngineFactory.cs           | 5 ++++-
 .../Implementation/FixedLengthFileMultiEngine.cs             | 3 +--
 src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs  | 1 +
 .../FixedLength/FixedLengthErrorHandlingTests.cs             | 1 +
 5 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs b/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs
index 1a9efcb..39ec8d2 100644
--- a/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs
+++ b/src/FlatFile.Delimited/Implementation/DelimitedFileEngineFactory.cs
@@ -100,17 +100,20 @@ public IFlatFileMultiEngine GetEngine(
         /// <param name="layoutDescriptors">The layout descriptors.</param>
         /// <param name="typeSelectorFunc">The type selector function.</param>
         /// <param name="handleEntryReadError">The handle entry read error func.</param>
+        /// <param name="masterDetailTracker">Determines how master-detail record relationships are handled.</param>
         /// <returns>IFlatFileMultiEngine.</returns>
         public IFlatFileMultiEngine GetEngine(
             IEnumerable<IDelimitedLayoutDescriptor> layoutDescriptors,
             Func<string, Type> typeSelectorFunc,
-            Func<FlatFileErrorContext, bool> handleEntryReadError)
+            Func<FlatFileErrorContext, bool> handleEntryReadError,
+            IMasterDetailTracker masterDetailTracker = null)
         {
             return new DelimitedFileMultiEngine(
                 layoutDescriptors,
                 typeSelectorFunc,
                 new DelimitedLineBuilderFactory(),
                 lineParserFactory,
+                masterDetailTracker ?? new DelimitedMasterDetailTracker(),
                 handleEntryReadError);
         }
     }
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
index f13547b..8b28f14 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileEngineFactory.cs
@@ -98,17 +98,20 @@ public IFlatFileMultiEngine GetEngine(
         /// <param name="layoutDescriptors">The layout descriptors.</param>
         /// <param name="typeSelectorFunc">The type selector function.</param>
         /// <param name="handleEntryReadError">The handle entry read error func.</param>
+        /// <param name="masterDetailTracker">Determines how master-detail record relationships are handled.</param>
         /// <returns>IFlatFileMultiEngine.</returns>
         public IFlatFileMultiEngine GetEngine(
             IEnumerable<ILayoutDescriptor<IFixedFieldSettingsContainer>> layoutDescriptors,
             Func<string, int, Type> typeSelectorFunc,
-            Func<FlatFileErrorContext, bool> handleEntryReadError)
+            Func<FlatFileErrorContext, bool> handleEntryReadError,
+            IMasterDetailTracker masterDetailTracker = null)
         {
             return new FixedLengthFileMultiEngine(
                 layoutDescriptors,
                 typeSelectorFunc,
                 new FixedLengthLineBuilderFactory(),
                 lineParserFactory,
+                masterDetailTracker ?? new FixedLengthMasterDetailTracker(),
                 handleEntryReadError);
         }
     }
diff --git a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
index 5a41c96..b4df606 100644
--- a/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
+++ b/src/FlatFile.FixedLength/Implementation/FixedLengthFileMultiEngine.cs
@@ -51,8 +51,8 @@ public class FixedLengthFileMultiEngine : FlatFileEngine<IFixedFieldSettingsCont
         /// <param name="typeSelectorFunc">The type selector function.</param>
         /// <param name="lineBuilderFactory">The line builder factory.</param>
         /// <param name="lineParserFactory">The line parser factory.</param>
-        /// <param name="handleEntryReadError">The handle entry read error.</param>
         /// <param name="masterDetailTracker">Determines how master-detail record relationships are handled.</param>
+        /// <param name="handleEntryReadError">The handle entry read error.</param>
         /// <exception cref="System.ArgumentNullException">typeSelectorFunc</exception>
         internal FixedLengthFileMultiEngine(
             IEnumerable<ILayoutDescriptor<IFixedFieldSettingsContainer>> layoutDescriptors,
@@ -60,7 +60,6 @@ internal FixedLengthFileMultiEngine(
             IFixedLengthLineBuilderFactory lineBuilderFactory,
             IFixedLengthLineParserFactory lineParserFactory,
             IMasterDetailTracker masterDetailTracker,
-            Func<string, Exception, bool> handleEntryReadError = null)
             Func<FlatFileErrorContext, bool> handleEntryReadError = null)
         {
             if (typeSelectorFunc == null) throw new ArgumentNullException("typeSelectorFunc");
diff --git a/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs b/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs
index 9793731..612be95 100644
--- a/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs
+++ b/src/FlatFile.Tests/Delimited/DelimitedErrorHandlingTests.cs
@@ -63,6 +63,7 @@ public void MultiEngineErrorContextShouldProvideAccurateInformation()
                 l => typeof(Record),
                 A.Fake<IDelimitedLineBuilderFactory>(),
                 lineParserFactory,
+                new DelimitedMasterDetailTracker(),
                 HandleError);
 
             using (var stream = new MemoryStream(Encoding.Default.GetBytes(TestData)))
diff --git a/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs b/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs
index c2bbb98..0895ebf 100644
--- a/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs
+++ b/src/FlatFile.Tests/FixedLength/FixedLengthErrorHandlingTests.cs
@@ -60,6 +60,7 @@ public void MultiEngineErrorContextShouldProvideAccurateInformation()
                 (l, i) => typeof(Record),
                 A.Fake<IFixedLengthLineBuilderFactory>(),
                 lineParserFactory,
+                new FixedLengthMasterDetailTracker(),
                 HandleError);
 
             using (var stream = new MemoryStream(Encoding.Default.GetBytes(TestData)))