Merge pull request #151 from freakingawesome/gather-unmapped-cells

Add a way to gather unmapped cells

Author: mrworkman

README.md

@@ -216,6 +216,40 @@ var excel = new ExcelQueryFactory("excelFileName");
 excel.StrictMapping = StrictMappingType.Both;
 ```
 
+### Retaining Values from Unmapped Columns
+
+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`.
+
+Let's say the only field you're guaranteed to have is a `Name` column, and the rest of the columns can be different per spreadsheet. You could write your `Company` class like this, implementing `IContainsUnmappedCells`:
+
+```c#
+public class Company : IContainsUnmappedCells
+{
+    public string Name { get; set; }
+    public IDictionary<string, Cell> UnmappedCells { get; } = new Dictionary<string, Cell>();
+}
+```
+
+Given the following data set:
+
+Name                                   | CEO           | EmployeeCount | StartDate
+-------------------------------------- | ------------- | ------------- | ----------
+ACME                                   | Bugs Bunny    | 25            | 1918-11-11
+Word Made Flesh                        | Chris Heuertz |               | 1994-08-08
+Anderson University                    | James Edwards |               | 1917-09-01
+
+You can query normally and all other fields will be available in the `UnmappedCells` dictionary:
+
+```c#
+var company = from c in excel.Worksheet<Company>()
+              where c.Name == "ACME"
+              select c;
+
+// company.UnmappedCells["CEO"] == "Bugs Bunny"
+// company.UnmappedCells["EmployeeCount"].Cast<int>() == 25
+// company.UnmappedCells["StartDate"].Cast<DateTime>() == new DateTime(1918, 11, 11)
+```
+
 ## 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

@@ -285,6 +285,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, fromType.Name).Cast(prop.PropertyType);
+                            var value = GetColumnValue(data, mapping.columnName, mapping.prop.Name, fromType.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);