fix: do not throw when access null item property (#290)

* fix: do not throw when access null item property

if your model has a complex property that is null and your template
has {{item.property.subproperty}} then it will NOT throw an error
letting the template continues to render

* fix: go to next cell after error getting data

after TargetInvocationException should go to next cell, otherwise
next values will be printed in wrong column

Co-authored-by: Gerson Dias <gersondias@outlook.com>

Author: GersonDias

ClosedXML.Report/RangeTemplate.cs

@@ -3,6 +3,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Dynamic.Core.Exceptions;
+using System.Reflection;
+
 using ClosedXML.Excel;
 using ClosedXML.Report.Excel;
 using ClosedXML.Report.Options;
@@ -94,7 +96,7 @@ private static RangeTemplate Parse(string name, IXLRange range, TempSheetBuffer
                     result._cells.AddNewRow();
             }
 
-            result._mergedRanges = sheet.MergedRanges.Where(x => range.Contains(x) && !innerRanges.Any(nr=>nr.Ranges.Any(r=>r.Contains(x)))).ToArray();
+            result._mergedRanges = sheet.MergedRanges.Where(x => range.Contains(x) && !innerRanges.Any(nr => nr.Ranges.Any(r => r.Contains(x)))).ToArray();
             sheet.MergedRanges.RemoveAll(result._mergedRanges.Contains);
 
             result.ParseTags(range);
@@ -132,21 +134,21 @@ private static IEnumerable<IXLNamedRange> GetInnerRanges(IXLRange prng)
         {
             var containings = prng.GetContainingNames().ToArray();
             return from nr in containings
-                let br = nr.Ranges
-                    .Any(rng => containings
-                        .Where(rr => rr != nr)
-                        .SelectMany(rr => rr.Ranges)
-                        .Any(r => r.Contains(rng)))
-                where !br
-                select nr;
+                   let br = nr.Ranges
+                       .Any(rng => containings
+                           .Where(rr => rr != nr)
+                           .SelectMany(rr => rr.Ranges)
+                           .Any(r => r.Contains(rng)))
+                   where !br
+                   select nr;
         }
 
         public IReportBuffer Generate(object[] items)
         {
             _evaluator.AddVariable("items", items);
             foreach (var v in _globalVariables)
             {
-                _evaluator.AddVariable("@"+v.Key, v.Value);
+                _evaluator.AddVariable("@" + v.Key, v.Value);
             }
             _rangeTags.Reset();
 
@@ -208,7 +210,7 @@ private void VerticalTable(object[] items, FormulaEvaluator evaluator)
                 }
 
                 var newRowRng = _buff.GetRange(startAddr, rowEnd);
-                foreach (var mrg in _mergedRanges.Where(r=>!_optionsRow.Contains(r)))
+                foreach (var mrg in _mergedRanges.Where(r => !_optionsRow.Contains(r)))
                 {
                     var newMrg = mrg.Relative(_rowRange, newRowRng);
                     newMrg.Merge(false);
@@ -258,7 +260,7 @@ private void VerticalTable(object[] items, FormulaEvaluator evaluator)
             {
                 _rangeTags.Execute(new ProcessingContext(resultRange, new DataSource(items), evaluator));
                 // if the range was increased by processing tags (for example, Group), move the buffer to the last cell
-                _buff.SetPrevCellToLastUsed(); 
+                _buff.SetPrevCellToLastUsed();
             }
         }
 
@@ -284,6 +286,28 @@ private void RenderCell(FormulaEvaluator evaluator, TemplateCell cell, params Pa
                 _errors.Add(new TemplateError(ex.Message, cell.XLCell.AsRange()));
                 return;
             }
+            catch (TargetInvocationException)
+            {
+                /*
+                 * item null complex objects results on TargetInvocationException when evaluating the lambda expression
+                 * eg: Given an Array {
+                 *   items: {
+                 *     name: string,
+                 *     foo?: {
+                 *        name: string
+                 *     }
+                 *   }[]
+                 *
+                 *   if in the template we have {{item.foo.name}} and in some of the items material property is null,
+                 *   this exception will be thrown.
+                 *
+                 *   just add to the error list for future use and keep doing the work, other items may have the material property.
+                 *   No need to write the error in the cell since it might be a desired behaviour, but needs to go to next cell.
+                 */
+                _buff.WriteValue(string.Empty, cell.XLCell);
+                _errors.Add(new TemplateError(string.Format("TargetInvocationException: {0}", cell.Value), cell.XLCell.AsRange()));
+                return;
+            }
 
             IXLCell xlCell;
             if (cell.CellType == TemplateCellType.Formula)
@@ -364,8 +388,8 @@ private void RenderSubrange(RangeTemplate ownRng, object item, FormulaEvaluator
                 else
                 {
                     // move current template cell to next (skip subrange)
-                    row += ownRng._rowCnt+1;
-                    while (_cells[iCell].Row <= row-1)
+                    row += ownRng._rowCnt + 1;
+                    while (_cells[iCell].Row <= row - 1)
                         iCell++;
 
                     iCell--; // roll back. After it became clear that it was too much, we must go back.

tests/ClosedXML.Report.Tests/RangeInterpreterTests.cs

@@ -87,6 +87,33 @@ public void CanBindRangesToAliasedVariableFields()
             AssertResultIsCorrect(ws);
         }
 
+        [Fact]
+        public void ShouldNotThrowExceptionIfAccessSomeChildrenNullProp()
+        {
+            var entity = new Order();
+
+            var template = CreateOrderTemplate();
+            var ws = template.Workbook.Worksheets.First();
+
+            ws.Range("A3:B4").AddToNamed("Items");
+
+            template.AddVariable(entity);
+            template.Generate();
+
+            ws.Cell("B3").Value.Should().Be(string.Empty);
+            ws.Cell("B4").Value.Should().Be("Material 1");
+        }
+
+        private XLTemplate CreateOrderTemplate()
+        {
+            var wbTemplate = new XLWorkbook();
+            var ws = wbTemplate.AddWorksheet();
+
+            ws.Cell("B3").Value = "{{item.Material.Name}}";
+
+            return new XLTemplate(wbTemplate);
+        }
+
         private XLTemplate CreateBaseTemplate()
         {
             var wbTemplate = new XLWorkbook();
@@ -123,6 +150,44 @@ private class Parent
             };
         }
 
+        private class Order
+        {
+            public string OrderNumber => "Order Number";
+            public List<Item> Items { get; } = new List<Item>
+            {
+                new Item("noMaterial", null),
+                new Item("withMaterial", new Material("Material 1"))
+            };
+        }
+
+        private class Item
+        {
+            public string Name { get; private set; }
+            public Material Material { get; private set; }
+
+            public Item(string name, Material material)
+            {
+                Name = name;
+                Material = material;
+            }
+
+            public Item AddMaterial(Material material)
+            {
+                Material = material;
+                return this;
+            }
+        }
+
+        private class Material
+        {
+            public string Name { get; }
+
+            public Material(string name)
+            {
+                Name = name;
+            }
+        }
+
         public class Child
         {
             public string ChildName { get; }