diff --git a/README.md b/README.md
index 347f1210..ae86d326 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 # BlazorTable
 [![Demo](https://img.shields.io/badge/Live-Demo-Blue?style=flat-square)](https://BlazorTable.netlify.com/)
 [![Nuget (with prereleases)](https://img.shields.io/nuget/vpre/BlazorTable.svg?style=flat-square)](https://www.nuget.org/packages/BlazorTable)
+[![Nuget (with prereleases)](https://img.shields.io/nuget/dt/BlazorTable.svg?style=flat-square)](https://www.nuget.org/packages/BlazorTable)
 ![](https://github.com/IvanJosipovic/BlazorTable/workflows/CI/CD/badge.svg)
 
 **Work in progress!**
diff --git a/src/BlazorTable.Sample/Pages/EditMode.razor b/src/BlazorTable.Sample/Pages/EditMode.razor
index 3c4d3c53..8e9f7f45 100644
--- a/src/BlazorTable.Sample/Pages/EditMode.razor
+++ b/src/BlazorTable.Sample/Pages/EditMode.razor
@@ -56,7 +56,7 @@
             <input type="number" step=".01" @bind-value="@context.fund" class="form-control form-control-sm" />
         </EditorTemplate>
     </Column>
-    <Column TableItem="PersonData" Title="Created Date" Property="@(x => x.created_date)" Sortable="true" Width="10%">
+    <Column TableItem="PersonData" Title="Created Date" Property="@(x => x.created_date)" Sortable="true" Filterable="true" Width="10%">
         <Template>
             @(context.created_date.HasValue ? context.created_date.Value.ToShortDateString() : string.Empty)
         </Template>
diff --git a/src/BlazorTable.Sample/Pages/Index.razor b/src/BlazorTable.Sample/Pages/Index.razor
index d558a477..6e767def 100644
--- a/src/BlazorTable.Sample/Pages/Index.razor
+++ b/src/BlazorTable.Sample/Pages/Index.razor
@@ -41,7 +41,7 @@
             @(context.fund.HasValue ? context.fund.Value.ToString("C") : string.Empty)
         </Template>
     </Column>
-    <Column TableItem="PersonData" Title="Created Date" Property="@(x => x.created_date)" Sortable="true" Width="10%">
+    <Column TableItem="PersonData" Title="Created Date" Property="@(x => x.created_date)" Sortable="true" Filterable="true" Width="10%">
         <Template>
             @(context.created_date.HasValue ? context.created_date.Value.ToShortDateString() : string.Empty)
         </Template>
diff --git a/src/BlazorTable/BlazorTable.csproj b/src/BlazorTable/BlazorTable.csproj
index b08ca3fc..c5a811a4 100644
--- a/src/BlazorTable/BlazorTable.csproj
+++ b/src/BlazorTable/BlazorTable.csproj
@@ -9,7 +9,7 @@
     <Authors>Ivan Josipovic</Authors>
     <PackageProjectUrl>https://github.com/IvanJosipovic/BlazorTable</PackageProjectUrl>
     <PackageTags>Blazor;Table;Grid;DataTable;Data;Sort;Filter;AspNetCore;AspNet</PackageTags>
-    <Version>0.0.5-alpha</Version>
+    <Version>0.0.6-alpha</Version>
     <PackageReleaseNotes>Experimental</PackageReleaseNotes>
     <PackageIcon>icon.png</PackageIcon>
   </PropertyGroup>
diff --git a/src/BlazorTable/Components/Column.razor b/src/BlazorTable/Components/Column.razor
index 64d40abc..ee1fafc3 100644
--- a/src/BlazorTable/Components/Column.razor
+++ b/src/BlazorTable/Components/Column.razor
@@ -10,7 +10,11 @@
                 <StringFilter TableItem="TableItem" />
                 <BooleanFilter TableItem="TableItem" />
                 <NumberFilter TableItem="TableItem" />
-                @*@this.CustomIFilters(this)*@
+                <DateFilter TableItem="TableItem" />
+                @*@if (this.CustomIFilters != null)
+                {
+                    this.CustomIFilters(this);
+                }*@
             </FilterManager>
 
         </BlazorStrap.BSPopoverBody>
diff --git a/src/BlazorTable/Components/Column.razor.cs b/src/BlazorTable/Components/Column.razor.cs
index a9610122..cc175207 100644
--- a/src/BlazorTable/Components/Column.razor.cs
+++ b/src/BlazorTable/Components/Column.razor.cs
@@ -1,6 +1,5 @@
 using Microsoft.AspNetCore.Components;
 using System;
-using System.Linq;
 using System.Linq.Expressions;
 
 namespace BlazorTable
@@ -50,7 +49,7 @@ public string Title
 
         public Type Type { get; private set; }
 
-        public IFilterManager<TableItem> FilterManager { get; set; }
+        public IFilter<TableItem> FilterControl { get; set; }
 
         public void Dispose()
         {
diff --git a/src/BlazorTable/Components/FilterManager.razor b/src/BlazorTable/Components/FilterManager.razor
index ffa83bff..5e161d5b 100644
--- a/src/BlazorTable/Components/FilterManager.razor
+++ b/src/BlazorTable/Components/FilterManager.razor
@@ -1,7 +1,7 @@
 @namespace BlazorTable
 @typeparam TableItem
 
-<CascadingValue Value="(IFilterManager<TableItem>)this" Name="FilterManager">
+<CascadingValue Value="(IColumn<TableItem>)this.Column" Name="Column">
     @ChildContent
 </CascadingValue>
 <br />
diff --git a/src/BlazorTable/Components/FilterManager.razor.cs b/src/BlazorTable/Components/FilterManager.razor.cs
index 0f47abec..012b3037 100644
--- a/src/BlazorTable/Components/FilterManager.razor.cs
+++ b/src/BlazorTable/Components/FilterManager.razor.cs
@@ -3,7 +3,7 @@
 
 namespace BlazorTable
 {
-    public partial class FilterManager<TableItem> : IFilterManager<TableItem>
+    public partial class FilterManager<TableItem>
     {
         [CascadingParameter(Name = "Column")] public IColumn<TableItem> Column { get; set; }
 
@@ -11,21 +11,21 @@ public partial class FilterManager<TableItem> : IFilterManager<TableItem>
 
         [Inject] public ILogger<FilterManager<TableItem>> Logger { get; set; }
 
-        public IFilter<TableItem> Filter { get; set; }
-
         protected override void OnInitialized()
         {
-            Column.FilterManager = this;
         }
 
         private void ApplyFilter()
         {
             Column.ToggleFilter();
-            if (Filter != null)
+            if (Column.FilterControl != null)
             {
-                Filter.ApplyFilter();
+                Column.Filter = Column.FilterControl.GetFilter();
                 Column.Table.Update();
                 Column.Table.FirstPage();
+            } else
+            {
+                Logger.LogInformation("Filter is null");
             }
         }
 
diff --git a/src/BlazorTable/Filters/BooleanFilter.razor b/src/BlazorTable/Filters/BooleanFilter.razor
index 96bd214d..d9ef07ae 100644
--- a/src/BlazorTable/Filters/BooleanFilter.razor
+++ b/src/BlazorTable/Filters/BooleanFilter.razor
@@ -1,7 +1,7 @@
 @namespace BlazorTable
 @typeparam TableItem
 
-@if (FilterTypes.Contains(FilterManager.Column.Type.GetNonNullableType()))
+@if (FilterTypes.Contains(Column.Type.GetNonNullableType()))
 {
     <select class="form-control form-control-sm" value="@Condition" @onchange="@((x) => Condition = (BooleanCondition)Enum.Parse(typeof(BooleanCondition), x.Value.ToString()))">
         @foreach (var option in (BooleanCondition[])Enum.GetValues(typeof(BooleanCondition)))
diff --git a/src/BlazorTable/Filters/BooleanFilter.razor.cs b/src/BlazorTable/Filters/BooleanFilter.razor.cs
index def54865..9b69b68c 100644
--- a/src/BlazorTable/Filters/BooleanFilter.razor.cs
+++ b/src/BlazorTable/Filters/BooleanFilter.razor.cs
@@ -9,7 +9,7 @@ namespace BlazorTable
 {
     public partial class BooleanFilter<TableItem> : IFilter<TableItem>
     {
-        [CascadingParameter(Name = "FilterManager")] public IFilterManager<TableItem> FilterManager { get; set; }
+        [CascadingParameter(Name = "Column")] public IColumn<TableItem> Column { get; set; }
 
         [Inject] public ILogger<NumberFilter<TableItem>> Logger { get; set; }
 
@@ -22,15 +22,15 @@ public partial class BooleanFilter<TableItem> : IFilter<TableItem>
 
         protected override void OnInitialized()
         {
-            if (FilterTypes.Contains(FilterManager.Column.Type.GetNonNullableType()))
+            if (FilterTypes.Contains(Column.Type.GetNonNullableType()))
             {
-                FilterManager.Filter = this;
+                Column.FilterControl = this;
 
-                if (FilterManager.Column.Filter != null)
+                if (Column.Filter != null)
                 {
-                    var nodeType = FilterManager.Column.Filter.Body.NodeType;
+                    var nodeType = Column.Filter.Body.NodeType;
 
-                    if (FilterManager.Column.Filter.Body is BinaryExpression binaryExpression
+                    if (Column.Filter.Body is BinaryExpression binaryExpression
                         && binaryExpression.NodeType == ExpressionType.AndAlso)
                     {
                         nodeType = binaryExpression.Right.NodeType;
@@ -55,35 +55,36 @@ protected override void OnInitialized()
             }
         }
 
-        public void ApplyFilter()
+        public Expression<Func<TableItem, bool>> GetFilter()
         {
             switch (Condition)
             {
                 case BooleanCondition.True:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
+                    return Expression.Lambda<Func<TableItem, bool>>(
                         Expression.AndAlso(
-                            Expression.NotEqual(FilterManager.Column.Property.Body, Expression.Constant(null)),
-                            Expression.IsTrue(Expression.Convert(FilterManager.Column.Property.Body, FilterManager.Column.Type.GetNonNullableType()))),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                            Expression.IsTrue(Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()))),
+                        Column.Property.Parameters);
+
                 case BooleanCondition.False:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
+                    return Expression.Lambda<Func<TableItem, bool>>(
                         Expression.AndAlso(
-                            Expression.NotEqual(FilterManager.Column.Property.Body, Expression.Constant(null)),
-                            Expression.IsFalse(Expression.Convert(FilterManager.Column.Property.Body, FilterManager.Column.Type.GetNonNullableType()))),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                            Expression.IsFalse(Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()))),
+                        Column.Property.Parameters);
+
                 case BooleanCondition.IsNull:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
-                        Expression.Equal(FilterManager.Column.Property.Body, Expression.Constant(null)),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                        Expression.Equal(Column.Property.Body, Expression.Constant(null)),
+                        Column.Property.Parameters);
+
                 case BooleanCondition.IsNotNull:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
-                        Expression.NotEqual(FilterManager.Column.Property.Body, Expression.Constant(null)),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                        Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                        Column.Property.Parameters);
             }
+
+            return null;
         }
     }
 
diff --git a/src/BlazorTable/Filters/DateFilter.razor b/src/BlazorTable/Filters/DateFilter.razor
new file mode 100644
index 00000000..83da9aa1
--- /dev/null
+++ b/src/BlazorTable/Filters/DateFilter.razor
@@ -0,0 +1,16 @@
+@namespace BlazorTable
+@typeparam TableItem
+
+@if (Column.Type.GetNonNullableType() == typeof(DateTime))
+{
+    <select class="form-control form-control-sm" value="@Condition" @onchange="@((x) => Condition = (NumberCondition)Enum.Parse(typeof(NumberCondition), x.Value.ToString()))">
+        @foreach (var option in (NumberCondition[])Enum.GetValues(typeof(NumberCondition)))
+        {
+            <option value="@option">@option.GetDescription()</option>
+        }
+    </select>
+    @if (Condition != NumberCondition.IsNull && Condition != NumberCondition.IsNotNull)
+    {
+        <input type="date" class="form-control form-control-sm" @bind-value="FilterValue" />
+    }
+}
\ No newline at end of file
diff --git a/src/BlazorTable/Filters/DateFilter.razor.cs b/src/BlazorTable/Filters/DateFilter.razor.cs
new file mode 100644
index 00000000..0f202ba0
--- /dev/null
+++ b/src/BlazorTable/Filters/DateFilter.razor.cs
@@ -0,0 +1,145 @@
+using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Globalization;
+using System.Linq.Expressions;
+
+namespace BlazorTable
+{
+    public partial class DateFilter<TableItem> : IFilter<TableItem>
+    {
+        [CascadingParameter(Name = "Column")] public IColumn<TableItem> Column { get; set; }
+
+        [Inject] public ILogger<NumberFilter<TableItem>> Logger { get; set; }
+
+        private NumberCondition Condition { get; set; }
+
+        private DateTime FilterValue { get; set; } = DateTime.Now;
+
+        protected override void OnInitialized()
+        {
+            if (Column.Type.GetNonNullableType() == typeof(DateTime))
+            {
+                Column.FilterControl = this;
+
+                if (Column.Filter?.Body is BinaryExpression binaryExpression)
+                {
+                    if (binaryExpression.NodeType == ExpressionType.AndAlso)
+                    {
+                        switch (binaryExpression.Right.NodeType)
+                        {
+                            case ExpressionType.Equal:
+                                Condition = NumberCondition.IsEqualTo;
+                                break;
+                            case ExpressionType.NotEqual:
+                                Condition = NumberCondition.IsNotEqualTo;
+                                break;
+                            case ExpressionType.GreaterThanOrEqual:
+                                Condition = NumberCondition.IsGreaterThanOrEqualTo;
+                                break;
+                            case ExpressionType.GreaterThan:
+                                Condition = NumberCondition.IsGreaterThan;
+                                break;
+                            case ExpressionType.LessThanOrEqual:
+                                Condition = NumberCondition.IsLessThanOrEqualTo;
+                                break;
+                            case ExpressionType.LessThan:
+                                Condition = NumberCondition.IsLessThan;
+                                break;
+                        }
+                    }
+                    else
+                    {
+                        if (binaryExpression.NodeType == ExpressionType.Equal)
+                        {
+                            Condition = NumberCondition.IsNull;
+                        }
+                        else if (binaryExpression.NodeType == ExpressionType.NotEqual)
+                        {
+                            Condition = NumberCondition.IsNotNull;
+                        }
+                    }
+
+                    if (binaryExpression.Right is BinaryExpression binaryExpression2 
+                        && binaryExpression2.Right is ConstantExpression constantExpression)
+                    {
+                        FilterValue = DateTime.Parse(constantExpression.Value.ToString(), CultureInfo.InvariantCulture);
+                    }
+                }
+            }
+        }
+
+        public Expression<Func<TableItem, bool>> GetFilter()
+        {
+            switch (Condition)
+            {
+                case NumberCondition.IsEqualTo:
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                        Expression.AndAlso(
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                            Expression.Equal(
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(FilterValue))),
+                        Column.Property.Parameters);
+
+                case NumberCondition.IsNotEqualTo:
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                        Expression.AndAlso(
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                            Expression.NotEqual(
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(FilterValue))),
+                        Column.Property.Parameters);
+
+                case NumberCondition.IsGreaterThanOrEqualTo:
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                        Expression.AndAlso(
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                            Expression.GreaterThanOrEqual(
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(FilterValue))),
+                        Column.Property.Parameters);
+
+                case NumberCondition.IsGreaterThan:
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                        Expression.AndAlso(
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                            Expression.GreaterThan(
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(FilterValue))),
+                        Column.Property.Parameters);
+
+                case NumberCondition.IsLessThanOrEqualTo:
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                        Expression.AndAlso(
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                            Expression.LessThanOrEqual(
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(FilterValue))),
+                        Column.Property.Parameters);
+
+                case NumberCondition.IsLessThan:
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                        Expression.AndAlso(
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                            Expression.LessThan(
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(FilterValue))),
+                        Column.Property.Parameters);
+
+                case NumberCondition.IsNull:
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                            Expression.Equal(Column.Property.Body, Expression.Constant(null)),
+                        Column.Property.Parameters);
+
+                case NumberCondition.IsNotNull:
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                        Column.Property.Parameters);
+
+                default:
+                    throw new ArgumentException(Condition + " is not defined!");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/BlazorTable/Filters/NumberFilter.razor b/src/BlazorTable/Filters/NumberFilter.razor
index 88a2bb2b..96ec84f8 100644
--- a/src/BlazorTable/Filters/NumberFilter.razor
+++ b/src/BlazorTable/Filters/NumberFilter.razor
@@ -1,7 +1,7 @@
 @namespace BlazorTable
 @typeparam TableItem
 
-@if (FilterManager.Column.Type.IsNumeric())
+@if (Column.Type.IsNumeric())
 {
     <select class="form-control form-control-sm" value="@Condition" @onchange="@((x) => Condition = (NumberCondition)Enum.Parse(typeof(NumberCondition), x.Value.ToString()))">
         @foreach (var option in (NumberCondition[])Enum.GetValues(typeof(NumberCondition)))
@@ -9,5 +9,8 @@
             <option value="@option">@option.GetDescription()</option>
         }
     </select>
-    <input type="number" class="form-control form-control-sm" @bind-value="FilterValue" />
+    @if (Condition != NumberCondition.IsNull && Condition != NumberCondition.IsNotNull)
+    {
+        <input type="number" class="form-control form-control-sm" @bind-value="FilterValue" />
+    }
 }
\ No newline at end of file
diff --git a/src/BlazorTable/Filters/NumberFilter.razor.cs b/src/BlazorTable/Filters/NumberFilter.razor.cs
index 0afdfa44..820e7908 100644
--- a/src/BlazorTable/Filters/NumberFilter.razor.cs
+++ b/src/BlazorTable/Filters/NumberFilter.razor.cs
@@ -2,13 +2,14 @@
 using Microsoft.Extensions.Logging;
 using System;
 using System.ComponentModel;
+using System.Globalization;
 using System.Linq.Expressions;
 
 namespace BlazorTable
 {
     public partial class NumberFilter<TableItem> : IFilter<TableItem>
     {
-        [CascadingParameter(Name = "FilterManager")] public IFilterManager<TableItem> FilterManager { get; set; }
+        [CascadingParameter(Name = "Column")] public IColumn<TableItem> Column { get; set; }
 
         [Inject] public ILogger<NumberFilter<TableItem>> Logger { get; set; }
 
@@ -18,130 +19,124 @@ public partial class NumberFilter<TableItem> : IFilter<TableItem>
 
         protected override void OnInitialized()
         {
-            if (FilterManager.Column.Type.IsNumeric())
+            if (Column.Type.IsNumeric())
             {
-                FilterManager.Filter = this;
+                Column.FilterControl = this;
 
-                if (FilterManager.Column.Filter != null)
+                if (Column.Filter?.Body is BinaryExpression binaryExpression)
                 {
-                    if (FilterManager.Column.Filter.Body is BinaryExpression binaryExpression)
+                    if (binaryExpression.NodeType == ExpressionType.AndAlso)
                     {
-                        if (binaryExpression.NodeType == ExpressionType.AndAlso)
+                        switch (binaryExpression.Right.NodeType)
                         {
-                            switch (binaryExpression.Right.NodeType)
-                            {
-                                case ExpressionType.Equal:
-                                    Condition = NumberCondition.IsEqualTo;
-                                    break;
-                                case ExpressionType.NotEqual:
-                                    Condition = NumberCondition.IsNotEqualTo;
-                                    break;
-                                case ExpressionType.GreaterThanOrEqual:
-                                    Condition = NumberCondition.IsGreaterThanOrEqualTo;
-                                    break;
-                                case ExpressionType.GreaterThan:
-                                    Condition = NumberCondition.IsGreaterThan;
-                                    break;
-                                case ExpressionType.LessThanOrEqual:
-                                    Condition = NumberCondition.IsLessThanOrEqualTo;
-                                    break;
-                                case ExpressionType.LessThan:
-                                    Condition = NumberCondition.IsLessThan;
-                                    break;
-                            }
+                            case ExpressionType.Equal:
+                                Condition = NumberCondition.IsEqualTo;
+                                break;
+                            case ExpressionType.NotEqual:
+                                Condition = NumberCondition.IsNotEqualTo;
+                                break;
+                            case ExpressionType.GreaterThanOrEqual:
+                                Condition = NumberCondition.IsGreaterThanOrEqualTo;
+                                break;
+                            case ExpressionType.GreaterThan:
+                                Condition = NumberCondition.IsGreaterThan;
+                                break;
+                            case ExpressionType.LessThanOrEqual:
+                                Condition = NumberCondition.IsLessThanOrEqualTo;
+                                break;
+                            case ExpressionType.LessThan:
+                                Condition = NumberCondition.IsLessThan;
+                                break;
                         }
-                        else
+                    }
+                    else
+                    {
+                        if (binaryExpression.NodeType == ExpressionType.Equal)
                         {
-                            if (binaryExpression.NodeType == ExpressionType.Equal)
-                            {
-                                Condition = NumberCondition.IsNull;
-                            }
-                            else if (binaryExpression.NodeType == ExpressionType.NotEqual)
-                            {
-                                Condition = NumberCondition.IsNotNull;
-                            }
+                            Condition = NumberCondition.IsNull;
                         }
-
-                        if (binaryExpression.Right is BinaryExpression binaryExpression2)
+                        else if (binaryExpression.NodeType == ExpressionType.NotEqual)
                         {
-                            if (binaryExpression2.Right is ConstantExpression constantExpression)
-                            {
-                                FilterValue = constantExpression.Value.ToString();
-                            }
+                            Condition = NumberCondition.IsNotNull;
                         }
                     }
+
+                    if (binaryExpression.Right is BinaryExpression binaryExpression2 
+                        && binaryExpression2.Right is ConstantExpression constantExpression)
+                    {
+                        FilterValue = constantExpression.Value.ToString();
+                    }
                 }
             }
         }
 
-        public void ApplyFilter()
+        public Expression<Func<TableItem, bool>> GetFilter()
         {
             switch (Condition)
             {
                 case NumberCondition.IsEqualTo:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
+                    return Expression.Lambda<Func<TableItem, bool>>(
                         Expression.AndAlso(
-                            Expression.NotEqual(FilterManager.Column.Property.Body, Expression.Constant(null)),
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
                             Expression.Equal(
-                                Expression.Convert(FilterManager.Column.Property.Body, FilterManager.Column.Type.GetNonNullableType()),
-                                Expression.Constant(Convert.ChangeType(FilterValue, FilterManager.Column.Type.GetNonNullableType())))),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(Convert.ChangeType(FilterValue, Column.Type.GetNonNullableType(), CultureInfo.InvariantCulture)))),
+                        Column.Property.Parameters);
+
                 case NumberCondition.IsNotEqualTo:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
+                    return Expression.Lambda<Func<TableItem, bool>>(
                         Expression.AndAlso(
-                            Expression.NotEqual(FilterManager.Column.Property.Body, Expression.Constant(null)),
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
                             Expression.NotEqual(
-                                Expression.Convert(FilterManager.Column.Property.Body, FilterManager.Column.Type.GetNonNullableType()),
-                                Expression.Constant(Convert.ChangeType(FilterValue, FilterManager.Column.Type.GetNonNullableType())))),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(Convert.ChangeType(FilterValue, Column.Type.GetNonNullableType(), CultureInfo.InvariantCulture)))),
+                        Column.Property.Parameters);
+
                 case NumberCondition.IsGreaterThanOrEqualTo:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
+                    return Expression.Lambda<Func<TableItem, bool>>(
                         Expression.AndAlso(
-                            Expression.NotEqual(FilterManager.Column.Property.Body, Expression.Constant(null)),
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
                             Expression.GreaterThanOrEqual(
-                                Expression.Convert(FilterManager.Column.Property.Body, FilterManager.Column.Type.GetNonNullableType()),
-                                Expression.Constant(Convert.ChangeType(FilterValue, FilterManager.Column.Type.GetNonNullableType())))),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(Convert.ChangeType(FilterValue, Column.Type.GetNonNullableType(), CultureInfo.InvariantCulture)))),
+                        Column.Property.Parameters);
+
                 case NumberCondition.IsGreaterThan:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
+                    return Expression.Lambda<Func<TableItem, bool>>(
                         Expression.AndAlso(
-                            Expression.NotEqual(FilterManager.Column.Property.Body, Expression.Constant(null)),
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
                             Expression.GreaterThan(
-                                Expression.Convert(FilterManager.Column.Property.Body, FilterManager.Column.Type.GetNonNullableType()),
-                                Expression.Constant(Convert.ChangeType(FilterValue, FilterManager.Column.Type.GetNonNullableType())))),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(Convert.ChangeType(FilterValue, Column.Type.GetNonNullableType(), CultureInfo.InvariantCulture)))),
+                        Column.Property.Parameters);
+
                 case NumberCondition.IsLessThanOrEqualTo:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
+                    return Expression.Lambda<Func<TableItem, bool>>(
                         Expression.AndAlso(
-                            Expression.NotEqual(FilterManager.Column.Property.Body, Expression.Constant(null)),
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
                             Expression.LessThanOrEqual(
-                                Expression.Convert(FilterManager.Column.Property.Body, FilterManager.Column.Type.GetNonNullableType()),
-                                Expression.Constant(Convert.ChangeType(FilterValue, FilterManager.Column.Type.GetNonNullableType())))),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(Convert.ChangeType(FilterValue, Column.Type.GetNonNullableType(), CultureInfo.InvariantCulture)))),
+                        Column.Property.Parameters);
+
                 case NumberCondition.IsLessThan:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
+                    return Expression.Lambda<Func<TableItem, bool>>(
                         Expression.AndAlso(
-                            Expression.NotEqual(FilterManager.Column.Property.Body, Expression.Constant(null)),
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
                             Expression.LessThan(
-                                Expression.Convert(FilterManager.Column.Property.Body, FilterManager.Column.Type.GetNonNullableType()),
-                                Expression.Constant(Convert.ChangeType(FilterValue, FilterManager.Column.Type.GetNonNullableType())))),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                                Expression.Convert(Column.Property.Body, Column.Type.GetNonNullableType()),
+                                Expression.Constant(Convert.ChangeType(FilterValue, Column.Type.GetNonNullableType(), CultureInfo.InvariantCulture)))),
+                        Column.Property.Parameters);
+
                 case NumberCondition.IsNull:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
-                            Expression.Equal(FilterManager.Column.Property.Body, Expression.Constant(null)),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                            Expression.Equal(Column.Property.Body, Expression.Constant(null)),
+                        Column.Property.Parameters);
+
                 case NumberCondition.IsNotNull:
-                    FilterManager.Column.Filter = Expression.Lambda<Func<TableItem, bool>>(
-                            Expression.NotEqual(FilterManager.Column.Property.Body, Expression.Constant(null)),
-                        FilterManager.Column.Property.Parameters);
-                    break;
+                    return Expression.Lambda<Func<TableItem, bool>>(
+                            Expression.NotEqual(Column.Property.Body, Expression.Constant(null)),
+                        Column.Property.Parameters);
                 default:
                     throw new ArgumentException(Condition + " is not defined!");
             }
diff --git a/src/BlazorTable/Filters/StringFilter.razor b/src/BlazorTable/Filters/StringFilter.razor
index 1475c337..700f15e2 100644
--- a/src/BlazorTable/Filters/StringFilter.razor
+++ b/src/BlazorTable/Filters/StringFilter.razor
@@ -1,7 +1,7 @@
 @namespace BlazorTable
 @typeparam TableItem
 
-@if (FilterManager.Column.Type == FilterType)
+@if (Column.Type == FilterType)
 {
     <select class="form-control form-control-sm" value="@Condition" @onchange="@((x) => Condition = (StringCondition)Enum.Parse(typeof(StringCondition), x.Value.ToString()))">
         @foreach (var option in (StringCondition[])Enum.GetValues(typeof(StringCondition)))
diff --git a/src/BlazorTable/Filters/StringFilter.razor.cs b/src/BlazorTable/Filters/StringFilter.razor.cs
index 59f395ab..5f7ca11c 100644
--- a/src/BlazorTable/Filters/StringFilter.razor.cs
+++ b/src/BlazorTable/Filters/StringFilter.razor.cs
@@ -8,7 +8,7 @@ namespace BlazorTable
 {
     public partial class StringFilter<TableItem> : IFilter<TableItem>
     {
-        [CascadingParameter(Name = "FilterManager")] public IFilterManager<TableItem> FilterManager { get; set; }
+        [CascadingParameter(Name = "Column")] public IColumn<TableItem> Column { get; set; }
 
         [Inject] public ILogger<StringFilter<TableItem>> Logger { get; set; }
 
@@ -20,17 +20,17 @@ public partial class StringFilter<TableItem> : IFilter<TableItem>
 
         protected override void OnInitialized()
         {
-            if (FilterManager.Column.Type == FilterType)
+            if (Column.Type == typeof(string))
             {
-                FilterManager.Filter = this;
+                Column.FilterControl = this;
 
-                if (FilterManager.Column.Filter != null)
+                if (Column.Filter != null)
                 {
                     bool NotCondition = false;
 
                     Expression method;
 
-                    if (FilterManager.Column.Filter.Body is UnaryExpression unary)
+                    if (Column.Filter.Body is UnaryExpression unary)
                     {
                         NotCondition = unary.NodeType == ExpressionType.Not;
 
@@ -38,7 +38,7 @@ protected override void OnInitialized()
                     }
                     else
                     {
-                        method = FilterManager.Column.Filter.Body;
+                        method = Column.Filter.Body;
                     }
 
                     if (method is MethodCallExpression methodCall)
@@ -56,41 +56,6 @@ protected override void OnInitialized()
             }
         }
 
-        public void ApplyFilter()
-        {
-            FilterText = FilterText?.Trim();
-
-            switch (Condition)
-            {
-                case StringCondition.Contains:
-                    FilterManager.Column.Filter = Utillities.CallMethodType(FilterManager.Column.Property, typeof(string), nameof(string.Contains), typeof(string), FilterText);
-                    break;
-                case StringCondition.DoesNotContain:
-                    FilterManager.Column.Filter = Utillities.CallMethodType(FilterManager.Column.Property, typeof(string), nameof(string.Contains), typeof(string), FilterText).Not();
-                    break;
-                case StringCondition.StartsWith:
-                    FilterManager.Column.Filter = Utillities.CallMethodType(FilterManager.Column.Property, typeof(string), nameof(string.StartsWith), typeof(string), FilterText);
-                    break;
-                case StringCondition.EndsWith:
-                    FilterManager.Column.Filter = Utillities.CallMethodType(FilterManager.Column.Property, typeof(string), nameof(string.EndsWith), typeof(string), FilterText);
-                    break;
-                case StringCondition.IsEqualTo:
-                    FilterManager.Column.Filter = Utillities.CallMethodType(FilterManager.Column.Property, typeof(string), nameof(string.Equals), typeof(string), FilterText);
-                    break;
-                case StringCondition.IsNotEqualTo:
-                    FilterManager.Column.Filter = Utillities.CallMethodType(FilterManager.Column.Property, typeof(string), nameof(string.Equals), typeof(string), FilterText).Not();
-                    break;
-                case StringCondition.IsNullOrEmpty:
-                    FilterManager.Column.Filter = Utillities.CallMethodTypeStaticSelf(FilterManager.Column.Property, typeof(string), nameof(string.IsNullOrEmpty), typeof(string));
-                    break;
-                case StringCondition.IsNotNulOrEmpty:
-                    FilterManager.Column.Filter = Utillities.CallMethodTypeStaticSelf(FilterManager.Column.Property, typeof(string), nameof(string.IsNullOrEmpty), typeof(string)).Not();
-                    break;
-                default:
-                    throw new ArgumentException(Condition + " is not defined!");
-            }
-        }
-
         private StringCondition GetConditionFromMethod(string method, bool not)
         {
             if (method == nameof(string.Contains) && !not)
@@ -128,6 +93,33 @@ private StringCondition GetConditionFromMethod(string method, bool not)
 
             throw new InvalidOperationException("Shouldn't be here");
         }
+
+        public Expression<Func<TableItem, bool>> GetFilter()
+        {
+            FilterText = FilterText?.Trim();
+
+            switch (Condition)
+            {
+                case StringCondition.Contains:
+                    return Utillities.CallMethodType(Column.Property, typeof(string), nameof(string.Contains), typeof(string), FilterText);
+                case StringCondition.DoesNotContain:
+                    return Utillities.CallMethodType(Column.Property, typeof(string), nameof(string.Contains), typeof(string), FilterText).Not();
+                case StringCondition.StartsWith:
+                    return Utillities.CallMethodType(Column.Property, typeof(string), nameof(string.StartsWith), typeof(string), FilterText);
+                case StringCondition.EndsWith:
+                    return Utillities.CallMethodType(Column.Property, typeof(string), nameof(string.EndsWith), typeof(string), FilterText);
+                case StringCondition.IsEqualTo:
+                    return Utillities.CallMethodType(Column.Property, typeof(string), nameof(string.Equals), typeof(string), FilterText);
+                case StringCondition.IsNotEqualTo:
+                    return Utillities.CallMethodType(Column.Property, typeof(string), nameof(string.Equals), typeof(string), FilterText).Not();
+                case StringCondition.IsNullOrEmpty:
+                    return Utillities.CallMethodTypeStaticSelf(Column.Property, typeof(string), nameof(string.IsNullOrEmpty), typeof(string));
+                case StringCondition.IsNotNulOrEmpty:
+                    return Utillities.CallMethodTypeStaticSelf(Column.Property, typeof(string), nameof(string.IsNullOrEmpty), typeof(string)).Not();
+                default:
+                    throw new ArgumentException(Condition + " is not defined!");
+            }
+        }
     }
 
     public enum StringCondition
diff --git a/src/BlazorTable/Interfaces/IColumn.cs b/src/BlazorTable/Interfaces/IColumn.cs
index 1a0b9412..1cd6f41c 100644
--- a/src/BlazorTable/Interfaces/IColumn.cs
+++ b/src/BlazorTable/Interfaces/IColumn.cs
@@ -6,6 +6,9 @@ namespace BlazorTable
 {
     public interface IColumn<TableItem>
     {
+        /// <summary>
+        /// Parent Table
+        /// </summary>
         ITable<TableItem> Table { get; set; }
 
         /// <summary>
@@ -48,8 +51,6 @@ public interface IColumn<TableItem>
         /// </summary>
         Type Type { get; }
 
-        IFilterManager<TableItem> FilterManager { get; set; }
-
         /// <summary>
         /// Property which this column is for<br />
         /// Required when Sortable = true<br />
@@ -72,6 +73,14 @@ public interface IColumn<TableItem>
         /// </summary>
         RenderFragment<TableItem> Template { get; set; }
 
+        /// <summary>
+        /// Currently applied Filter Control
+        /// </summary>
+        IFilter<TableItem> FilterControl { get; set; }
+
+        /// <summary>
+        /// Place custom controls which implement IFilter
+        /// </summary>
         RenderFragment<Column<TableItem>> CustomIFilters { get; set; }
 
         /// <summary>
diff --git a/src/BlazorTable/Interfaces/IFilter.cs b/src/BlazorTable/Interfaces/IFilter.cs
index 316061da..2fdcf641 100644
--- a/src/BlazorTable/Interfaces/IFilter.cs
+++ b/src/BlazorTable/Interfaces/IFilter.cs
@@ -1,9 +1,10 @@
 using System;
+using System.Linq.Expressions;
 
 namespace BlazorTable
 {
     public interface IFilter<TableItem>
     {
-        void ApplyFilter();
+        Expression<Func<TableItem, bool>> GetFilter();
     }
 }
diff --git a/src/BlazorTable/Interfaces/IFilterManager.cs b/src/BlazorTable/Interfaces/IFilterManager.cs
deleted file mode 100644
index 7f3fc435..00000000
--- a/src/BlazorTable/Interfaces/IFilterManager.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using Microsoft.AspNetCore.Components;
-using Microsoft.Extensions.Logging;
-using System.Collections.Generic;
-
-namespace BlazorTable
-{
-    public interface IFilterManager<TableItem>
-    {
-        IColumn<TableItem> Column { get; }
-
-        IFilter<TableItem> Filter { get; set; }
-    }
-}
\ No newline at end of file