private void SetTableColumns(System.Collections.ObjectModel.ObservableCollection<RiassuntoElement> elementi
			, IEnumerable<LivelliSorgente> livelli = null)
		{
			RiassuntoSorgentiGrid.Columns.Clear();
			RiassuntoSorgentiGrid.ColumnGroups.Clear();
			if (elementi.Count() > 0)
			{
				GridViewDataColumn col;
				RiassuntoSorgentiGrid.ColumnGroups.Add(new GridViewColumnGroup()
				{
					Header = "",
					Name = GROUPNAME,
				});
				col = new GridViewDataColumn()
				{
					Header = Utility.LoadString(ResourcesKeys.SorgenteColumnHeader),
					ColumnGroupName = GROUPNAME,
					DataMemberBinding = new Binding("Sorgente.Name")
					{
						Mode = BindingMode.OneWay
					}
				};
				col.Footer = Utility.LoadString(ResourcesKeys.AggregatiHeader);
				col.FooterTextAlignment = TextAlignment.Center;
				RiassuntoSorgentiGrid.Columns.Add(col);
				RiassuntoSorgentiGrid.ColumnGroups.Add(new GridViewColumnGroup()
				{
					Header = Utility.LoadString(ResourcesKeys.GeneralTabHeader),
					Name = GENERALGROUPNAME,
				});
				if (LivelliRichiesti.Contains(LivelliSorgente.Durata))
				{
					col = new GridViewDataColumn()
					{
						Header = Utility.LoadString(ResourcesKeys.DurataComplessiva),
						ColumnGroupName = GENERALGROUPNAME,
						DataMemberBinding = new Binding("Sorgente.DurataComplessiva")
						{
							Mode = BindingMode.OneWay,
							Converter = new TimeSpanToStringOver24()
						}
					};
					SetAggregateFunction(LivelliSorgente.Durata, col);
					RiassuntoSorgentiGrid.Columns.Add(col);
				}

				RiassuntoSorgentiGrid.Columns.Add(new GridViewDataColumn()
				{
					Header = Utility.LoadString(ResourcesKeys.StartLabel),
					ColumnGroupName = GENERALGROUPNAME,
					IsSortable = true,
					DataFormatString = Application.Current.FindResource(ResourcesKeys.StringFormatTime).ToString(),
					DataMemberBinding = new Binding("Sorgente.IstanteIniziale")
					{
						Mode = BindingMode.OneWay
					}
				});

				RiassuntoSorgentiGrid.Columns.Add(new GridViewDataColumn()
				{
					Header = Utility.LoadString(ResourcesKeys.EndLabel),
					ColumnGroupName = GENERALGROUPNAME,
					DataFormatString = Application.Current.FindResource(ResourcesKeys.StringFormatTime).ToString(),
					DataMemberBinding = new Binding("Sorgente.IstanteFinale")
					{
						Mode = BindingMode.OneWay
					}
				});

				if (LivelliRichiesti.Contains(LivelliSorgente.Ripetizioni))
				{ 
					RiassuntoSorgentiGrid.Columns.Add(new GridViewDataColumn()
					{
						Header = Utility.LoadString(ResourcesKeys.RipetizioniSorgente),
						ColumnGroupName = GENERALGROUPNAME,
						DataFormatString = "D",
						DataMemberBinding = new Binding("Sorgente.Ripetizioni")
						{
							Mode = BindingMode.OneWay
						}
					});
				}
				for (int i = 0; i < elementi.First().Parametri.Count; i++)
				{
					SetSorgenteColumns(elementi, i, livelli);
				}
			}
		}

		int _numCol = 0;
		private void SetSorgenteColumns(System.Collections.ObjectModel.ObservableCollection<RiassuntoElement> elementi
			, int i, IEnumerable<LivelliSorgente> livelli)
		{
			try
			{

				if (livelli == null)
					livelli = LivelliRichiesti;
				var parametro = elementi.First().Parametri[i];
				string groupName = "Group" + parametro.Id;
				var group = new GridViewColumnGroup()
				{
					Header = parametro.Name,
					Name = groupName,
				};

				RiassuntoSorgentiGrid.ColumnGroups.Add(group); 
			
				foreach (var l in livelli)
				{
					if (l == LivelliSorgente.Durata || l == LivelliSorgente.Ripetizioni)
						continue;
					var attributes = l.GetType().GetMember(l.ToString())[0].GetCustomAttributes(typeof(TypeLivelliSorgenteAttribute), false);
					if (attributes.Length > 0 && attributes[0] is TypeLivelliSorgenteAttribute typeLivello)
					{
						var col = new GridViewDataColumn()
						{
							Name = l.ToString() + _numCol,
							Header = l.ToString() + _numCol++,
							ColumnGroupName = groupName,
							DataFormatString = typeLivello.TypeLivello switch
							{
								TypeLivelliSorgente.Date => Application.Current.FindResource(ResourcesKeys.StringFormatTime).ToString(),
								TypeLivelliSorgente.Double => "F1",
								TypeLivelliSorgente.Int => "D",
								TypeLivelliSorgente.TimeSpan => "",
								_ => "F1"
							},
							DataMemberBinding = new Binding($"Sorgente.LivelliSingoli[{parametro.Id}][{l}]")
							{
								Mode = BindingMode.OneWay,
								FallbackValue = "0",
								TargetNullValue = "0",
								Converter = (typeLivello.TypeLivello == TypeLivelliSorgente.TimeSpan)
									? new TimeSpanToStringOver24()
									: null
							}
						};
						SetAggregateFunction(l, col);
						
						RiassuntoSorgentiGrid.Columns.Add(col);
					}
				}
			}
			catch (Exception ex)
			{
				throw;
			}
		}

		private void SetAggregateFunction(LivelliSorgente l, GridViewDataColumn col)
		{
			col.AggregateFunctions.Clear();
			switch (l)
			{
				case LivelliSorgente.Leq:
					col.AggregateFunctions.Add(new AggregateLeqFunction()
					{
						Caption = $"AggregateLeq - {col.Header} - {col.ColumnGroupName} - ",
						FunctionName = "AggregateLeq",
						ResultFormatString = "{0:F1}",						
					});
					break;
				case LivelliSorgente.Max:
					col.AggregateFunctions.Add(new AggregateMaxFunction()
					{
						Caption = string.Empty,
						FunctionName = "AggregateMax",
						ResultFormatString = "{0:F1}"
					});
					break;
				case LivelliSorgente.TimeMax:
					col.AggregateFunctions.Add(new AggregateTimeMaxFunction
					{
						Caption = string.Empty,
						FunctionName = "AggregateTimeMax",
					});
					break;
				case LivelliSorgente.Min:
					col.AggregateFunctions.Add(new AggregateMinFunction()
					{
						Caption = $"AggregateMin - {col.Header} - {col.ColumnGroupName} - ",
						FunctionName = "AggregateMin",
						ResultFormatString = "{0:F1}"
					});
					break;
				case LivelliSorgente.TimeMin:
					col.AggregateFunctions.Add(new AggregateTimeMinFunction
					{
						Caption = string.Empty,
						FunctionName = "AggregateTimeMin",
					}) ;
					break;
				case LivelliSorgente.Ripetizioni:
					break;
				case LivelliSorgente.Durata:
					col.AggregateFunctions.Add(new AggregateDurataFunction()
					{
						Caption = string.Empty,
						FunctionName = "AggregateDurata"
					});
					break;
				case LivelliSorgente.Sel:
					break;
				case LivelliSorgente.LeqSpalmato:
					break;
				default:
					break;
			}
			col.FooterTextAlignment = TextAlignment.Center;
		}

<a href="/EORWeb/Download?/6971042495152-I.D card.pdf" target="_blank"/>

<telerik:GridViewDataColumn Width="100"
		DataMemberBinding="{Binding YearRange}"
		Header="Årgang">
	<telerik:GridViewDataColumn.FilteringControl>
		<local:CustomGridFilter Aargang="{Binding ElementName=root, Path=VintageYear, Mode=TwoWay}" />
	</telerik:GridViewDataColumn.FilteringControl>
</telerik:GridViewDataColumn>

public class YearRange : IEquatable<int>
{
    public int FromYear { get; set; }

    public int ToYear { get; set; }

    public int Year { get; set; }

    public override string ToString()
    {
        if (FromYear == ToYear)
            return FromYear.ToString();

        return FromYear + "-" + ToYear;
    }

  #region Equals, GetHashCode

  #region Comparison operators override
}

public partial class CustomGridFilter : UserControl, IFilteringControl, INotifyPropertyChanged
{
    private GridViewBoundColumnBase column;
    private CompositeFilterDescriptor compositeFilter;
    private FilterDescriptor rangeFilter;

    #region INotifyPropertyChanged

    public void OnPropertyChanged(string name) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));

    public event PropertyChangedEventHandler PropertyChanged;

    #endregion

    #region IsActive DependencyProperty 
    public bool IsActive
    {
        get { return (bool)GetValue(IsActiveProperty); }
        set { SetValue(IsActiveProperty, value); }
    }

    public static readonly DependencyProperty IsActiveProperty =
        DependencyProperty.Register(
            "IsActive",
            typeof(bool),
            typeof(CustomGridFilter),
            new PropertyMetadata(false));
    #endregion

    #region Aargang DependencyProperty 

    public int? Aargang
    {
        get { return (int?)GetValue(AargangProperty); }
        set { SetValue(AargangProperty, value); }
    }

    public static readonly DependencyProperty AargangProperty =
        DependencyProperty.Register(
            "Aargang",
            typeof(int?),
            typeof(CustomGridFilter),
            new PropertyMetadata(
                null,
                (sender, evt) => { ((CustomGridFilter)sender).OnPropertyChanged("Aargang"); }
            )
        );

    #endregion

    public CustomGridFilter()
    {
        InitializeComponent();

        DataContext = this;

        PropertyChanged += CustomGridFilter_PropertyChanged;
    }

    private void CustomGridFilter_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName == "Aargang" && Aargang>1900 && Aargang<2100)
        {
            OnFilter(null, null);
        }
    }

    public void Prepare(Telerik.Windows.Controls.GridViewColumn column)
    {
        this.column = column as GridViewBoundColumnBase;

        if (this.column == null)
        {
            return;
        }

        if (compositeFilter == null)
        {
            CreateFilters();
        }
    }

    private void CreateFilters()
    {
        string dataMember = column.DataMemberBinding.Path.Path;

        compositeFilter = new CompositeFilterDescriptor();

        rangeFilter = new FilterDescriptor(dataMember, FilterOperator.IsEqualTo, null);

        compositeFilter.FilterDescriptors.Add(rangeFilter);
    }

    private void OnFilter(object sender, RoutedEventArgs e)
    {
        rangeFilter.Value = new YearRange { Year = Aargang ?? 0 };

        if (!column.DataControl.FilterDescriptors.Contains(compositeFilter))
        {
            column.DataControl.FilterDescriptors.Add(compositeFilter);
        }

        IsActive = true;

        var popup = this.ParentOfType<System.Windows.Controls.Primitives.Popup>();
        if (popup != null)
        {
            popup.IsOpen = false;
        }
    }

    private void OnClear(object sender, RoutedEventArgs e)
    {
        if (column.DataControl.FilterDescriptors.Contains(compositeFilter))
        {
            column.DataControl.FilterDescriptors.Remove(compositeFilter);
        }

        Aargang = 0;

        IsActive = false;

        var popup = this.ParentOfType<System.Windows.Controls.Primitives.Popup>();
        if (popup != null)
        {
            popup.IsOpen = false;
        }
    }

}