Add a way to gather unmapped cells

Author: freakingawesome

README.md

@@ -215,6 +215,8 @@ var excel = new ExcelQueryFactory("excelFileName");
 excel.StrictMapping = StrictMappingType.Both;
 ```
 
+If you are using `None` or `ClassStrict` mapping, you can retain unmapped columns by implementing the `IContainsUnmappedCells` interface. This will put all values from the unmapped columns into a dictionary on your class named `UnmappedCells`.
+
 ## Manually setting the database engine
 
 LinqToExcel can use the Jet or Ace database engine, and it automatically determines the database engine to use by the file extension. You can manually set the database engine with the `DatabaseEngine` property

src/LinqToExcel.Tests/CompanyNameWithUnmappedCells.cs

@@ -0,0 +1,16 @@
+
+using System.Collections.Generic;
+
+namespace LinqToExcel.Tests
+{
+	class CompanyNameWithUnmappedCells : IContainsUnmappedCells
+	{
+		public CompanyNameWithUnmappedCells()
+		{
+			UnmappedCells = new Dictionary<string, Cell>();
+		}
+
+		public string Name { get; set; }
+		public IDictionary<string, Cell> UnmappedCells { get; private set; }
+	}
+}

src/LinqToExcel.Tests/ExcelQueryFactoryTests.cs

@@ -284,6 +284,24 @@ public void StrictMapping_Not_Explicitly_Set_with_additional_class_properties_do
             Assert.AreEqual(1, companies.Count);
         }
 
+        [Test]
+        public void IContainsUnmappedCells_FillsInUnmappedCells()
+        {
+            var excel = new ExcelQueryFactory(_excelFileName, new LogManagerFactory());
+            excel.AddMapping<Company>(x => x.IsActive, "Active");
+
+            var companies = (from c in excel.Worksheet<CompanyNameWithUnmappedCells>()
+                             where c.Name == "ACME"
+                             select c).ToList();
+
+            Assert.AreEqual(1, companies.Count);
+            Assert.AreEqual("ACME", companies[0].Name);
+            Assert.AreEqual(3, companies.First().UnmappedCells.Count);
+            Assert.AreEqual("Bugs Bunny", companies.First().UnmappedCells["CEO"].Value);
+            Assert.AreEqual(25, companies.First().UnmappedCells["EmployeeCount"].Cast<int>());
+            Assert.AreEqual(new DateTime(1918, 11, 11), companies.First().UnmappedCells["StartDate"].Cast<DateTime>());
+        }
+
         [Test]
         public void TrimSpaces_Start_TrimsWhiteSpacesAtTheBeginning()
         {

src/LinqToExcel.Tests/LinqToExcel.Tests.csproj

@@ -92,6 +92,7 @@
     <Compile Include="CompanyNullable.cs" />
     <Compile Include="CompanyWithColumnAnnotations.cs" />
     <Compile Include="CompanyWithCity.cs" />
+    <Compile Include="CompanyNameWithUnmappedCells.cs" />
     <Compile Include="ConfiguredWorksheetName_SQLStatements_UnitTests.cs" />
     <Compile Include="ConfiguredWorksheetName_IntegrationTests.cs" />
     <Compile Include="Convention_SQLStatements_UnitTests.cs" />

src/LinqToExcel/Domain/IContainsUnmappedCells.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace LinqToExcel
+{
+	/// <summary>
+	/// Implement this interface to receive values for cells that
+	/// were not mapped.
+	/// </summary>
+	public interface IContainsUnmappedCells
+	{
+		IDictionary<string, Cell> UnmappedCells { get; }
+	}
+}

src/LinqToExcel/LinqToExcel.csproj

@@ -84,6 +84,7 @@
   <ItemGroup>
     <Compile Include="Attributes\ExcelColumnAttribute.cs" />
     <Compile Include="Domain\Cell.cs" />
+    <Compile Include="Domain\IContainsUnmappedCells.cs" />
     <Compile Include="Domain\RowNoHeader.cs" />
     <Compile Include="Domain\StrictMappingException.cs" />
     <Compile Include="Exceptions\ExcelException.cs" />

src/LinqToExcel/Query/ExcelQueryExecutor.cs

@@ -316,29 +316,50 @@ private IEnumerable<object> GetTypeResults(IDataReader data, IEnumerable<string>
             var props = fromType.GetProperties();
             if (_args.StrictMapping.Value != StrictMappingType.None)
                 this.ConfirmStrictMapping(columns, props, _args.StrictMapping.Value);
+            var gatherUnmappedCells = typeof(IContainsUnmappedCells).IsAssignableFrom(fromType);
 
             var currentRowNumber = 0;
             while (data.Read())
             {
                 currentRowNumber++;
                 var result = Activator.CreateInstance(fromType);
-                foreach (var prop in props)
+
+                var propMapping = props.Select(prop => new
                 {
-                    var columnName = (_args.ColumnMappings.ContainsKey(prop.Name)) ?
+                    prop,
+                    columnName = (_args.ColumnMappings.ContainsKey(prop.Name)) ?
                         _args.ColumnMappings[prop.Name] :
-                        prop.Name;
+                        prop.Name
+                });
+
+                foreach (var mapping in propMapping)
+                {
                     try
                     {
-                        if (columns.Contains(columnName))
+                        if (columns.Contains(mapping.columnName))
                         {
-                            var value = GetColumnValue(data, columnName, prop.Name).Cast(prop.PropertyType);
+                            var value = GetColumnValue(data, mapping.columnName, mapping.prop.Name).Cast(mapping.prop.PropertyType);
                             value = TrimStringValue(value);
-                            result.SetProperty(prop.Name, value);
+                            result.SetProperty(mapping.prop.Name, value);
                         }
                     }
                     catch (Exception exception)
                     {
-                        throw new Exceptions.ExcelException(currentRowNumber, columnName, exception);
+                        throw new Exceptions.ExcelException(currentRowNumber, mapping.columnName, exception);
+                    }
+                }
+
+                if (gatherUnmappedCells)
+                {
+                    var gatherer = (IContainsUnmappedCells)result;
+                    if (gatherer.UnmappedCells != null)
+                    {
+                        foreach (var col in columns.Except(propMapping.Select(x => x.columnName)))
+                        {
+                            var value = data[col];
+                            value = TrimStringValue(value);
+                            gatherer.UnmappedCells[col] = new Cell(value);
+                        }
                     }
                 }
                 results.Add(result);