diff --git a/Dexiom.EPPlusExporter.Net45/Dexiom.EPPlusExporter.Net45.csproj b/Dexiom.EPPlusExporter.Net45/Dexiom.EPPlusExporter.Net45.csproj
index cb6af31..a6a0964 100644
--- a/Dexiom.EPPlusExporter.Net45/Dexiom.EPPlusExporter.Net45.csproj
+++ b/Dexiom.EPPlusExporter.Net45/Dexiom.EPPlusExporter.Net45.csproj
@@ -56,6 +56,12 @@
     <Compile Include="..\Dexiom.EPPlusExporter\ColumnHeaderConfiguration.cs">
       <Link>ColumnHeaderConfiguration.cs</Link>
     </Compile>
+    <Compile Include="..\Dexiom.EPPlusExporter\DisplayField.cs">
+      <Link>DisplayField.cs</Link>
+    </Compile>
+    <Compile Include="..\Dexiom.EPPlusExporter\DynamicProperty.cs">
+      <Link>DynamicProperty.cs</Link>
+    </Compile>
     <Compile Include="..\Dexiom.EPPlusExporter\EnumerableExporter.cs">
       <Link>EnumerableExporter.cs</Link>
     </Compile>
diff --git a/Dexiom.EPPlusExporter/Dexiom.EPPlusExporter.csproj b/Dexiom.EPPlusExporter/Dexiom.EPPlusExporter.csproj
index 200db88..50e4907 100644
--- a/Dexiom.EPPlusExporter/Dexiom.EPPlusExporter.csproj
+++ b/Dexiom.EPPlusExporter/Dexiom.EPPlusExporter.csproj
@@ -46,6 +46,8 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="DisplayField.cs" />
+    <Compile Include="DynamicProperty.cs" />
     <Compile Include="ColumnContentConfiguration.cs" />
     <Compile Include="ColumnHeaderConfiguration.cs" />
     <Compile Include="Extensions\IDictionaryExtensions.cs" />
diff --git a/Dexiom.EPPlusExporter/DisplayField.cs b/Dexiom.EPPlusExporter/DisplayField.cs
new file mode 100644
index 0000000..363d3ef
--- /dev/null
+++ b/Dexiom.EPPlusExporter/DisplayField.cs
@@ -0,0 +1,52 @@
+using System;
+using System.ComponentModel;
+using System.Reflection;
+using Dexiom.EPPlusExporter.Helpers;
+
+namespace Dexiom.EPPlusExporter
+{
+    public class DisplayField<T> where T : class
+    {
+        private readonly PropertyInfo _propertyInfo;
+        private readonly DynamicProperty<T> _dynamicProperty;
+
+        public DisplayField(PropertyInfo propertyInfo)
+        {
+            _propertyInfo = propertyInfo;
+
+            Name = _propertyInfo.Name;
+            DisplayName = ReflectionHelper.GetPropertyDisplayName(_propertyInfo);
+            Type = _propertyInfo.PropertyType;
+        }
+
+        public DisplayField(DynamicProperty<T> dynamicProperty)
+        {
+            _dynamicProperty = dynamicProperty;
+
+            Name = _dynamicProperty.Name;
+            DisplayName = _dynamicProperty.DisplayName;
+            Type = _dynamicProperty.ValueType;
+        }
+
+        #region Properties
+        public string Name { get; set; }
+        public string DisplayName { get; set; }
+        public Type Type { get; set; }
+        #endregion
+
+        public object GetValue(T item)
+        {
+            if (_propertyInfo != null)
+            {
+#if NET4
+                return _propertyInfo.GetValue(item, null);
+#endif
+#if NET45 || NET46
+            return  _propertyInfo.GetValue(item);
+#endif
+            }
+
+            return _dynamicProperty.GetValue(item);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Dexiom.EPPlusExporter/DynamicProp.cs b/Dexiom.EPPlusExporter/DynamicProp.cs
new file mode 100644
index 0000000..71180b9
--- /dev/null
+++ b/Dexiom.EPPlusExporter/DynamicProp.cs
@@ -0,0 +1,22 @@
+using System;
+
+namespace Dexiom.EPPlusExporter
+{
+    public static class DynamicProperty
+    {
+        public static DynamicProp<T> Create<T>(Func<T, object> getValue, Type valueType) where T : class => new DynamicProp<T>(getValue, valueType);
+    }
+
+    public class DynamicProp<T>
+    {
+        public DynamicProp(Func<T, object> getValue, Type valueType)
+        {
+            ValueType = valueType;
+            GetValue = getValue;
+        }
+
+
+        public Type ValueType { get; set; }
+        public Func<T, object> GetValue { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Dexiom.EPPlusExporter/DynamicProperty.cs b/Dexiom.EPPlusExporter/DynamicProperty.cs
new file mode 100644
index 0000000..b5f90db
--- /dev/null
+++ b/Dexiom.EPPlusExporter/DynamicProperty.cs
@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+
+namespace Dexiom.EPPlusExporter
+{
+    #region Create Method (using type inference)
+    public static class DynamicProperty
+    {
+        public static DynamicProperty<T> Create<T>(IEnumerable<T> data, string name, string displayName, Type valueType, Func<T, object> getValue) where T : class
+        {
+            return new DynamicProperty<T>()
+            {
+                Name = name,
+                DisplayName = displayName,
+                ValueType = valueType,
+                GetValue = getValue
+            };
+        }
+    }
+    #endregion
+
+    public class DynamicProperty<T> 
+        where T : class
+    {
+        public string Name { get; set; }
+        public string DisplayName { get; set; }
+        public Type ValueType { get; set; }
+        public Func<T, object> GetValue { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Dexiom.EPPlusExporter/EnumerableExporter.cs b/Dexiom.EPPlusExporter/EnumerableExporter.cs
index aace3a9..0d5dbb7 100644
--- a/Dexiom.EPPlusExporter/EnumerableExporter.cs
+++ b/Dexiom.EPPlusExporter/EnumerableExporter.cs
@@ -1,40 +1,43 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Linq;
 using System.Linq.Expressions;
+using System.Net.Configuration;
 using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
-using Dexiom.EPPlusExporter.Extensions;
 using Dexiom.EPPlusExporter.Helpers;
 using OfficeOpenXml;
-using OfficeOpenXml.Style;
 using OfficeOpenXml.Table;
 
 namespace Dexiom.EPPlusExporter
 {
-#region Create Method (using type inference)
-    public class EnumerableExporter
+    #region Create Method (using type inference)
+    public static class EnumerableExporter
     {
         public static EnumerableExporter<T> Create<T>(IEnumerable<T> data, TableStyles tableStyles = TableStyles.Medium4) where T : class => new EnumerableExporter<T>(data) { TableStyle = tableStyles };
+        public static EnumerableExporter<T> Create<T>(IEnumerable<T> data, IEnumerable<DynamicProperty<T>> dynamicProperties, TableStyles tableStyles = TableStyles.Medium4) where T : class => new EnumerableExporter<T>(data, dynamicProperties) { TableStyle = tableStyles };
     }
-#endregion
+    #endregion
 
     public class EnumerableExporter<T> : TableExporter<T>
         where T : class
     {
         public IEnumerable<T> Data { get; set; }
+        public IEnumerable<DynamicProperty<T>> DynamicProperties { get; set; }
 
-#region Constructors
+        #region Constructors
         public EnumerableExporter(IEnumerable<T> data)
         {
             Data = data;
         }
-#endregion
 
-#region Protected
+        public EnumerableExporter(IEnumerable<T> data, IEnumerable<DynamicProperty<T>> dynamicProperties)
+        {
+            Data = data;
+            DynamicProperties = dynamicProperties;
+        }
+        #endregion
+
+        #region Protected
         protected override ExcelRange AddWorksheet(ExcelPackage package)
         {
             const int headerFirstRow = 1;
@@ -46,17 +49,51 @@ protected override ExcelRange AddWorksheet(ExcelPackage package)
                 return null;
 
             //let's avoid multiple enumeration
-            var myData = Data as IList<T> ?? Data.ToList();
+            var data = Data as IList<T> ?? Data.ToList();
+            IList<DynamicProperty<T>> dynamicProperties = null;
+            if (DynamicProperties != null)
+                dynamicProperties = DynamicProperties as IList<DynamicProperty<T>> ?? DynamicProperties.ToList();
 
             //get available properties
-            var properties = ReflectionHelper.GetBaseTypeOfEnumerable(Data).GetProperties()
-                .Where(p => !IgnoredProperties.Contains(p.Name));
+            var properties = ReflectionHelper.GetBaseTypeOfEnumerable(data).GetProperties()
+                .Where(p => !IgnoredProperties.Contains(p.Name))
+                .ToList();
 
             //resolve displayed properties
-            var displayedProperties = DisplayedProperties?.Select(propName => properties.FirstOrDefault(n => n.Name == propName)).Where(propInfo => propInfo != null).ToList() ?? properties.ToList();
+            HashSet<string> allPropertyNames;
+            if (DisplayedProperties != null)
+            {
+                allPropertyNames = DisplayedProperties;
+            }
+            else
+            {
+                allPropertyNames = new HashSet<string>(properties.Select(n => n.Name));
+                if (dynamicProperties != null)
+                {
+                    foreach (var dynamicPropertyName in dynamicProperties.Select(n => n.Name))
+                        allPropertyNames.Add(dynamicPropertyName);
+                }
+            }
+
+            var displayFields = new List<DisplayField<T>>();
+            foreach (var propertyName in allPropertyNames)
+            {
+                var property = properties.FirstOrDefault(n => n.Name == propertyName);
+                if (property != null)
+                {
+                    //displayedProperties.Add(property); //todo: delete me
+                    displayFields.Add(new DisplayField<T>(property));
+                }
+                else
+                {
+                    var dynamicProperty = DynamicProperties?.FirstOrDefault(n => n.Name == propertyName);
+                    if (dynamicProperty != null)
+                        displayFields.Add(new DisplayField<T>(dynamicProperty));
+                }
+            }
 
             //init the configurations
-            var columnConfigurations = GetColumnConfigurations(displayedProperties.Select(n => n.Name));
+            var columnConfigurations = GetColumnConfigurations(displayFields.Select(n => n.Name));
 
             //create the worksheet
             var worksheet = package.Workbook.Worksheets.Add(WorksheetName);
@@ -64,11 +101,11 @@ protected override ExcelRange AddWorksheet(ExcelPackage package)
             //Create table header
             {
                 var col = headerFirstCol;
-                foreach (var property in displayedProperties)
+                foreach (var displayField in displayFields)
                 {
-                    var colConfig = columnConfigurations[property.Name];
+                    var colConfig = columnConfigurations[displayField.Name];
                     var cell = worksheet.Cells[headerFirstRow, col];
-                    cell.Value = string.IsNullOrEmpty(colConfig.Header.Text) ? ReflectionHelper.GetPropertyDisplayName(property) : colConfig.Header.Text;
+                    cell.Value = string.IsNullOrEmpty(colConfig.Header.Text) ? displayField.DisplayName : colConfig.Header.Text;
                     colConfig.Header.SetStyle(cell.Style);
 
                     col++;
@@ -77,13 +114,13 @@ protected override ExcelRange AddWorksheet(ExcelPackage package)
 
             //Add rows
             var row = dataFirstRow;
-            foreach (var item in myData)
+            foreach (var item in data)
             {
                 var iCol = dataFirstCol;
-                foreach (var property in displayedProperties)
+                foreach (var displayField in displayFields)
                 {
                     var cell = worksheet.Cells[row, iCol];
-                    cell.Value = GetPropertyValue(property, item);
+                    cell.Value = ApplyTextFormat(displayField.Name, displayField.GetValue(item));
 
                     iCol++;
                 }
@@ -91,8 +128,8 @@ protected override ExcelRange AddWorksheet(ExcelPackage package)
             }
             
             //get bottom & right bounds
-            var dataLastCol = dataFirstCol + displayedProperties.Count - 1;
-            var dataLastRow = dataFirstRow + Math.Max(myData.Count, 1) - 1; //make sure to have at least 1 data line (for table format)
+            var dataLastCol = dataFirstCol + displayFields.Count - 1;
+            var dataLastRow = dataFirstRow + Math.Max(data.Count, 1) - 1; //make sure to have at least 1 data line (for table format)
             var tableRange = worksheet.Cells[headerFirstRow, headerFirstCol, dataLastRow, dataLastCol];
             
             WorksheetHelper.FormatAsTable(tableRange, TableStyle, WorksheetName, false);
@@ -100,14 +137,14 @@ protected override ExcelRange AddWorksheet(ExcelPackage package)
             //apply configurations
             {
                 var iCol = dataFirstCol;
-                foreach (var property in displayedProperties)
+                foreach (var displayField in displayFields)
                 {
-                    var colConfig = columnConfigurations[property.Name];
+                    var colConfig = columnConfigurations[displayField.Name];
                     var columnRange = worksheet.Cells[dataFirstRow, iCol, dataLastRow, iCol];
 
                     //apply default number format
-                    if (DefaultNumberFormats.ContainsKey(property.PropertyType))
-                        columnRange.Style.Numberformat.Format = DefaultNumberFormats[property.PropertyType];
+                    if (DefaultNumberFormats.ContainsKey(displayField.Type))
+                        columnRange.Style.Numberformat.Format = DefaultNumberFormats[displayField.Type];
 
                     //apply number format
                     if (colConfig.Content.NumberFormat != null)
@@ -129,14 +166,14 @@ protected override ExcelRange AddWorksheet(ExcelPackage package)
             //apply conditional styles
             {
                 var iCol = dataFirstCol;
-                foreach (var property in displayedProperties)
+                foreach (var displayField in displayFields)
                 {
-                    if (ConditionalStyles.ContainsKey(property.Name))
+                    if (ConditionalStyles.ContainsKey(displayField.Name))
                     {
-                        var conditionalStyle = ConditionalStyles[property.Name];
+                        var conditionalStyle = ConditionalStyles[displayField.Name];
 
                         var iRow = dataFirstRow;
-                        foreach (var item in myData)
+                        foreach (var item in data)
                         {
                             var cell = worksheet.Cells[iRow, iCol];
                             conditionalStyle(item, cell.Style); //apply style on cell
@@ -151,14 +188,14 @@ protected override ExcelRange AddWorksheet(ExcelPackage package)
             //apply conditional styles
             {
                 var iCol = dataFirstCol;
-                foreach (var property in displayedProperties)
+                foreach (var displayField in displayFields)
                 {
-                    if (Formulas.ContainsKey(property.Name))
+                    if (Formulas.ContainsKey(displayField.Name))
                     {
-                        var formulaFormat = Formulas[property.Name];
+                        var formulaFormat = Formulas[displayField.Name];
 
                         var iRow = dataFirstRow;
-                        foreach (var item in myData)
+                        foreach (var item in data)
                         {
                             var cell = worksheet.Cells[iRow, iCol];
                             var formula = formulaFormat(item, cell.Value); //apply style on cell
@@ -176,6 +213,6 @@ protected override ExcelRange AddWorksheet(ExcelPackage package)
             return tableRange;
         }
 
-#endregion
+        #endregion
     }
 }
diff --git a/Dexiom.EPPlusExporter/Interfaces/ITableOutputCustomization.cs b/Dexiom.EPPlusExporter/Interfaces/ITableOutputCustomization.cs
index dbe52dd..5bcd912 100644
--- a/Dexiom.EPPlusExporter/Interfaces/ITableOutputCustomization.cs
+++ b/Dexiom.EPPlusExporter/Interfaces/ITableOutputCustomization.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq.Expressions;
 using OfficeOpenXml;
 using OfficeOpenXml.Style;
@@ -8,33 +9,44 @@ namespace Dexiom.EPPlusExporter.Interfaces
     public interface ITableOutputCustomization<T> 
         where T : class
     {
-        TableExporter<T> Configure<TProperty>(Expression<Func<T, TProperty>> property, Action<ColumnConfiguration> column);
+        TableExporter<T> Configure<TProperty>(Expression<Func<T, TProperty>> properties, Action<ColumnConfiguration> column);
+        TableExporter<T> Configure(IEnumerable<string> propertyNames, Action<ColumnConfiguration> column);
         
         TableExporter<T> CustomizeTable(Action<ExcelRange> applyCustomization);
 
 
         #region Shorthands for configure
 
-        TableExporter<T> StyleFor<TProperty>(Expression<Func<T, TProperty>> property, Action<ExcelStyle> setStyle);
+        TableExporter<T> StyleFor<TProperty>(Expression<Func<T, TProperty>> properties, Action<ExcelStyle> setStyle);
+        TableExporter<T> StyleFor(IEnumerable<string> propertyNames, Action<ExcelStyle> setStyle);
 
-        TableExporter<T> HeaderStyleFor<TProperty>(Expression<Func<T, TProperty>> property, Action<ExcelStyle> setStyle);
+        TableExporter<T> HeaderStyleFor<TProperty>(Expression<Func<T, TProperty>> properties, Action<ExcelStyle> setStyle);
+        TableExporter<T> HeaderStyleFor(IEnumerable<string> propertyNames, Action<ExcelStyle> setStyle);
 
-        TableExporter<T> NumberFormatFor<TProperty>(Expression<Func<T, TProperty>> property, string numberFormat);
+        TableExporter<T> NumberFormatFor<TProperty>(Expression<Func<T, TProperty>> properties, string numberFormat);
+        TableExporter<T> NumberFormatFor(IEnumerable<string> propertyNames, string numberFormat);
 
         #endregion
 
 
         #region Misc
+        TableExporter<T> DefaultNumberFormat(Type type, string numberFormat);
 
-        TableExporter<T> Display<TProperty>(Expression<Func<T, TProperty>> property);
+        TableExporter<T> Display<TProperty>(Expression<Func<T, TProperty>> properties);
+        TableExporter<T> Display(IEnumerable<string> propertyNames);
 
-        TableExporter<T> Ignore<TProperty>(Expression<Func<T, TProperty>> property);
+        TableExporter<T> Ignore<TProperty>(Expression<Func<T, TProperty>> properties);
+        TableExporter<T> Ignore(IEnumerable<string> propertyNames);
 
-        TableExporter<T> DefaultNumberFormat(Type type, string numberFormat);
 
-        TableExporter<T> TextFormatFor<TProperty>(Expression<Func<T, TProperty>> property, string format);
-        
-        TableExporter<T> ConditionalStyleFor<TProperty>(Expression<Func<T, TProperty>> property, Action<T, ExcelStyle> setStyle);
+        TableExporter<T> TextFormatFor<TProperty>(Expression<Func<T, TProperty>> properties, string format);
+        TableExporter<T> TextFormatFor(IEnumerable<string> propertyNames, string format);
+
+        TableExporter<T> ConditionalStyleFor<TProperty>(Expression<Func<T, TProperty>> properties, Action<T, ExcelStyle> setStyle);
+        TableExporter<T> ConditionalStyleFor(IEnumerable<string> propertyNames, Action<T, ExcelStyle> setStyle);
+
+        TableExporter<T> FormulaFor<TProperty>(Expression<Func<T, TProperty>> properties, Func<T, object, string> formulaFormat);
+        TableExporter<T> FormulaFor(IEnumerable<string> propertyNames, Func<T, object, string> formulaFormat);
 
         #endregion
     }
diff --git a/Dexiom.EPPlusExporter/TableExporter.cs b/Dexiom.EPPlusExporter/TableExporter.cs
index 4af8150..691fa8a 100644
--- a/Dexiom.EPPlusExporter/TableExporter.cs
+++ b/Dexiom.EPPlusExporter/TableExporter.cs
@@ -58,38 +58,35 @@ public ExcelWorksheet AppendToExcelPackage(ExcelPackage package)
 
         #region ITableOutputCustomization<T>
 
-        public TableExporter<T> Configure<TProperty>(Expression<Func<T, TProperty>> property, Action<ColumnConfiguration> column)
+        public TableExporter<T> Configure<TProperty>(Expression<Func<T, TProperty>> properties, Action<ColumnConfiguration> column) => Configure(PropertyNames.For(properties), column);
+        public TableExporter<T> Configure(IEnumerable<string> propertyNames, Action<ColumnConfiguration> column)
         {
-            foreach (var propName in PropertyNames.For(property))
+            foreach (var propName in propertyNames)
                 _columnAlterations.Add(new KeyValuePair<string, Action<ColumnConfiguration>>(propName, column));
 
             return this;
         }
-        
+
         public TableExporter<T> CustomizeTable(Action<ExcelRange> applyCustomization)
         {
             _tableCustomizations.Add(applyCustomization);
             return this;
         }
 
-        public TableExporter<T> StyleFor<TProperty>(Expression<Func<T, TProperty>> property, Action<ExcelStyle> setStyle)
-        {
-            Configure(property, c => c.Content.SetStyle = setStyle);
-            return this;
-        }
 
-        public TableExporter<T> HeaderStyleFor<TProperty>(Expression<Func<T, TProperty>> property, Action<ExcelStyle> setStyle)
-        {
-            Configure(property, c => c.Header.SetStyle = setStyle);
-            return this;
-        }
+        public TableExporter<T> StyleFor<TProperty>(Expression<Func<T, TProperty>> properties, Action<ExcelStyle> setStyle) => StyleFor(PropertyNames.For(properties), setStyle);
+        public TableExporter<T> StyleFor(IEnumerable<string> propertyNames, Action<ExcelStyle> setStyle) => Configure(propertyNames, c => c.Content.SetStyle = setStyle);
 
-        public TableExporter<T> NumberFormatFor<TProperty>(Expression<Func<T, TProperty>> property, string numberFormat)
-        {
-            Configure(property, c => c.Content.NumberFormat = numberFormat);
-            return this;
-        }
 
+        public TableExporter<T> HeaderStyleFor<TProperty>(Expression<Func<T, TProperty>> properties, Action<ExcelStyle> setStyle) => HeaderStyleFor(PropertyNames.For(properties), setStyle);
+        public TableExporter<T> HeaderStyleFor(IEnumerable<string> propertyNames, Action<ExcelStyle> setStyle) => Configure(propertyNames, c => c.Header.SetStyle = setStyle);
+
+
+        public TableExporter<T> NumberFormatFor<TProperty>(Expression<Func<T, TProperty>> properties, string numberFormat) => NumberFormatFor(PropertyNames.For(properties), numberFormat);
+        public TableExporter<T> NumberFormatFor(IEnumerable<string> propertyNames, string numberFormat) => Configure(propertyNames, c => c.Content.NumberFormat = numberFormat);
+
+
+        public TableExporter<T> Display<TProperty>(Expression<Func<T, TProperty>> properties) => Display(PropertyNames.For(properties));
         public TableExporter<T> Display(IEnumerable<string> propertyNames)
         {
             if (DisplayedProperties == null)
@@ -100,14 +97,9 @@ public TableExporter<T> Display(IEnumerable<string> propertyNames)
 
             return this;
         }
-        
-        public TableExporter<T> Display<TProperty>(Expression<Func<T, TProperty>> properties)
-        {
-            Display(PropertyNames.For(properties));
 
-            return this;
-        }
 
+        public TableExporter<T> Ignore<TProperty>(Expression<Func<T, TProperty>> properties) => Ignore(PropertyNames.For(properties));
         public TableExporter<T> Ignore(IEnumerable<string> propertyNames)
         {
             foreach (var propName in propertyNames)
@@ -116,11 +108,6 @@ public TableExporter<T> Ignore(IEnumerable<string> propertyNames)
             return this;
         }
 
-        public TableExporter<T> Ignore<TProperty>(Expression<Func<T, TProperty>> properties)
-        {
-            Ignore(PropertyNames.For(properties));
-            return this;
-        }
 
         public TableExporter<T> DefaultNumberFormat(Type type, string numberFormat)
         {
@@ -128,31 +115,35 @@ public TableExporter<T> DefaultNumberFormat(Type type, string numberFormat)
             return this;
         }
 
-        public TableExporter<T> TextFormatFor<TProperty>(Expression<Func<T, TProperty>> property, string format)
+
+        public TableExporter<T> TextFormatFor<TProperty>(Expression<Func<T, TProperty>> properties, string format) => TextFormatFor(PropertyNames.For(properties), format);
+        public TableExporter<T> TextFormatFor(IEnumerable<string> propertyNames, string format)
         {
-            foreach (var propName in PropertyNames.For(property))
+            foreach (var propName in propertyNames)
                 TextFormats.AddOrUpdate(propName, format);
 
             return this;
         }
-        
-        public TableExporter<T> ConditionalStyleFor<TProperty>(Expression<Func<T, TProperty>> property, Action<T, ExcelStyle> setStyle)
+
+        public TableExporter<T> ConditionalStyleFor<TProperty>(Expression<Func<T, TProperty>> properties, Action<T, ExcelStyle> setStyle) => ConditionalStyleFor(PropertyNames.For(properties), setStyle);
+        public TableExporter<T> ConditionalStyleFor(IEnumerable<string> propertyNames, Action<T, ExcelStyle> setStyle)
         {
-            foreach (var propName in PropertyNames.For(property))
+            foreach (var propName in propertyNames)
                 ConditionalStyles.AddOrUpdate(propName, setStyle);
 
             return this;
         }
-        
-        public TableExporter<T> FormulaFor<TProperty>(Expression<Func<T, TProperty>> property, Func<T, object, string> formulaFormat)
+
+        public TableExporter<T> FormulaFor<TProperty>(Expression<Func<T, TProperty>> properties, Func<T, object, string> formulaFormat) => FormulaFor(PropertyNames.For(properties), formulaFormat);
+        public TableExporter<T> FormulaFor(IEnumerable<string> propertyNames, Func<T, object, string> formulaFormat)
         {
-            foreach (var propName in PropertyNames.For(property))
+            foreach (var propName in propertyNames)
                 Formulas.AddOrUpdate(propName, formulaFormat);
 
             return this;
         }
         #endregion
-        
+
         #region Protected
         protected Dictionary<string, string> TextFormats { get; } = new Dictionary<string, string>();
 
@@ -178,8 +169,14 @@ protected object GetPropertyValue(PropertyInfo property, object item)
 #if NET45 || NET46
             var value = property.GetValue(item);
 #endif
-            if (value != null && TextFormats.ContainsKey(property.Name))
-                return string.Format(TextFormats[property.Name], value);
+
+            return ApplyTextFormat(property.Name, value);
+        }
+
+        protected object ApplyTextFormat(string propertyName, object value)
+        {
+            if (value != null && TextFormats.ContainsKey(propertyName))
+                return string.Format(TextFormats[propertyName], value);
 
             return value;
         }
diff --git a/Dexiom.EPPlusExporterTests/EnumerableExporterTests.cs b/Dexiom.EPPlusExporterTests/EnumerableExporterTests.cs
index 765745c..38e7b5b 100644
--- a/Dexiom.EPPlusExporterTests/EnumerableExporterTests.cs
+++ b/Dexiom.EPPlusExporterTests/EnumerableExporterTests.cs
@@ -86,7 +86,13 @@ public void ConfigureTest()
                 new { TextValue = "SomeText", DateValue = DateTime.Now, DoubleValue = 10.2, IntValue = 5}
             };
 
-            var excelPackage = EnumerableExporter.Create(data)
+            var dynamicProperties = new[]
+            {
+                DynamicProperty.Create(data, "DynamicColumn1", "Display Name 1", typeof(DateTime?), n => DateTime.Now.AddDays(n.IntValue - 4)),
+                DynamicProperty.Create(data, "DynamicColumn2", "Display Name 2", typeof(double), n => n.DoubleValue - 0.2)
+            };
+
+            var excelPackage = EnumerableExporter.Create(data, dynamicProperties)
                 .Configure(n => n.IntValue, configuration =>
                 {
                     configuration.Header.Text = "";
@@ -105,6 +111,14 @@ public void ConfigureTest()
                         style.Border.Right.Style = ExcelBorderStyle.Dashed;
                     };
                 })
+                .Configure(new []{ "DynamicColumn1", "IntValue" }, n =>
+                    {
+                        n.Header.SetStyle = style =>
+                        {
+                            style.Font.Bold = true;
+                            style.Font.Color.SetColor(Color.Black);
+                        };
+                    })
                 .CustomizeTable(range =>
                 {
                     var newRange = range.Worksheet.Cells[range.End.Row, range.Start.Column, range.End.Row, range.End.Column];
@@ -113,7 +127,7 @@ public void ConfigureTest()
                 })
                 .CreateExcelPackage();
 
-            //TestHelper.OpenDocument(excelPackage);
+            TestHelper.OpenDocument(excelPackage);
 
 
             var excelWorksheet = excelPackage.Workbook.Worksheets.First();
@@ -166,18 +180,31 @@ public void DefaultNumberFormatTest()
                 new { TextValue = "SomeText", DateValue = DateTime.Now, DoubleValue = 10.2, IntValue = 5}
             };
 
-            var excelWorksheet = EnumerableExporter.Create(data)
-                .DefaultNumberFormat(typeof(DateTime), "DATE: yyyy-MM-dd")
+            var dynamicProperties = new[]
+            {
+                DynamicProperty.Create(data, "DynamicColumn1", "Display Name 1", typeof(DateTime?), n => DateTime.Now.AddDays(n.IntValue - 4)),
+                DynamicProperty.Create(data, "DynamicColumn2", "Display Name 2", typeof(double), n => n.DoubleValue - 0.2)
+            };
+
+
+            var excelPackage = EnumerableExporter.Create(data, dynamicProperties)
+                .DefaultNumberFormat(typeof(DateTime), "| yyyy-MM-dd")
+                .DefaultNumberFormat(typeof(DateTime?), "|| yyyy-MM-dd")
                 .DefaultNumberFormat(typeof(double), "0.00 $")
                 .DefaultNumberFormat(typeof(int), "00")
-                .CreateExcelPackage()
-                .Workbook.Worksheets.First();
+                .CreateExcelPackage();
+            var excelWorksheet = excelPackage.Workbook.Worksheets.First();
+
+            //TestHelper.OpenDocument(excelPackage);
 
             string numberDecimalSeparator = NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
-            
-            Assert.IsTrue(excelWorksheet.Cells[2, 2].Text == DateTime.Today.ToString("DATE: yyyy-MM-dd")); //DateValue
+
+            Assert.IsTrue(excelWorksheet.Cells[2, 2].Text == DateTime.Today.ToString("| yyyy-MM-dd")); //DateValue
             Assert.IsTrue(excelWorksheet.Cells[2, 3].Text == $"10{numberDecimalSeparator}20 $"); //DoubleValue
             Assert.IsTrue(excelWorksheet.Cells[2, 4].Text == "05"); //IntValue
+            Assert.IsTrue(excelWorksheet.Cells[2, 5].Text == DateTime.Today.AddDays(1).ToString("|| yyyy-MM-dd")); //DynamicColumn1
+            Assert.IsTrue(excelWorksheet.Cells[2, 6].Text == $"10{numberDecimalSeparator}00 $"); //DynamicColumn2
+
         }
 
         [TestMethod()]
@@ -250,6 +277,7 @@ public void TextFormatForTest()
                 new { TextValue = "SomeText", DateValue = DateTime.Now, DoubleValue = 10.2, IntValue = 5}
             };
 
+
             const string textFormat = "Prefix: {0}";
             const string dateFormat = "{0:yyyy-MM-dd HH:mm}";
             var exporter = EnumerableExporter.Create(data)