Can I get an enum value having a given description attribute using a generic function?

Question

I'm creating a generic filtering user control to allow the user to apply various filters on a CollectionView, on an WPF app.

So, I have a filled CollectionView with entities, with properties. So, instead of creating a different user control for each entity, I came up with this:

foreach (PropertyInfo propertyInfo in _typeMessaging.Mensagem.GetProperties())
{
    var attrs = propertyInfo.GetCustomAttributes(true);
    foreach (object attr in attrs)
    {
        if (attr is DescriptionAttribute descr)
            fields.Add(new FilteringInfo() { Property = propertyInfo, Description = descr.Description }); ;
    }
}

foreach (FilteringInfo filteringInfo in fields.OrderBy(x => x.Property.Name))
{
    Columns.Add(filteringInfo);
}

So I just bind Columns to a combo box and the user can select which column (i.e. property) they want to filter their view by, all I need is to set the properties I want the user to be able to filter by with a description attribute. If the property type is string, DateTime, int or decimal, the user simply enters the info they want to filter by and it generates a filter to be applied on parent ViewModel's CollectionView. It then returns a FilteringInfo object to the parent ViewModel, which has the chosen PropertyInfo and the value the user wants to filter by preceded by a filtering word as a parameter.

This FilteringInfo is passed to a FiltersCollection which stores all the filters requested by the user and returns a Filter to be added to the CollectionView:

public class FiltersCollection
{
    private readonly GroupFilter _filtros = new();
    public Predicate<object> AddNewFilter(EntityBase entity)
    {
        FilteringInfo filteringInfo = entity as FilteringInfo;
        switch (filteringInfo.FilterInfo.Split(':')[0])
        {
            case "wholefield":
                _filtros.AddFilter(x => x is EntityBase entityBase && ((string)entityBase.GetPropValue(filteringInfo.Property.Name)).Equals(filteringInfo.FilterInfo.Split(':')[1], StringComparison.OrdinalIgnoreCase));
                break;
            case "contains":
                _filtros.AddFilter(x => x is EntityBase entityBase && ((string)entityBase.GetPropValue(filteringInfo.Property.Name)).Contains(filteringInfo.FilterInfo.Split(':')[1], StringComparison.OrdinalIgnoreCase));
                break;
            case "startswith":
                _filtros.AddFilter(x => x is EntityBase entityBase && ((string)entityBase.GetPropValue(filteringInfo.Property.Name)).StartsWith(filteringInfo.FilterInfo.Split(':')[1], StringComparison.OrdinalIgnoreCase));
                break;
            case "datebetween":
                string[] dates = filteringInfo.FilterInfo.Split(':')[1].Split(';');
                DateTime start = DateTime.Parse(dates[0]);
                DateTime end = DateTime.Parse(dates[1]).AddDays(1).AddSeconds(-1);
                _filtros.AddFilter(x => x is EntityBase entityBase && ((DateTime)entityBase.GetPropValue(filteringInfo.Property.Name)).IsBetween(start, end));
                break;
            case "valuebetween":
                string[] valuesBetween = filteringInfo.FilterInfo.Split(':')[1].Split(';');
                decimal startValue = decimal.Parse(valuesBetween[0]);
                decimal endValue = decimal.Parse(valuesBetween[1]);
                _filtros.AddFilter(x => x is EntityBase entityBase && ((decimal)entityBase.GetPropValue(filteringInfo.Property.Name)).IsBetween(startValue, endValue));
                break;
            case "enumvalue":
                _filtros.AddFilter(x => x is EntityBase entityBase && ((Enum)entityBase.GetPropValue(filteringInfo.Property.Name)).Equals(Enum.Parse(filteringInfo.Property.PropertyType, filteringInfo.FilterInfo.Split(':')[1])));
                break;
            case "abovevalue":
                string[] values = filteringInfo.FilterInfo.Split(':')[1].Split(';');
                if (filteringInfo.Property.PropertyType == typeof(int))
                {
                    int headValue = int.Parse(values[0]);
                    _filtros.AddFilter(x => x is EntityBase entityBase && (int)entityBase.GetPropValue(filteringInfo.Property.Name) >= headValue);
                }
                if (filteringInfo.Property.PropertyType == typeof(decimal))
                {
                    decimal headValue = decimal.Parse(values[0]);
                    _filtros.AddFilter(x => x is EntityBase entityBase && (decimal)entityBase.GetPropValue(filteringInfo.Property.Name) >= headValue);
                }
                break;
            case "clearfilters":
                _filtros.RemoveAllFilters();
                return null;
        }
        return _filtros.Filter;
    }
}

GroupFilter:

public class GroupFilter
{
    private List<Predicate<object>> _filters;

    public Predicate<object> Filter { get; private set; }

    public GroupFilter()
    {
        _filters = new List<Predicate<object>>();
        Filter = InternalFilter;
    }

    private bool InternalFilter(object o)
    {
        foreach (var filter in _filters)
        {
            if (!filter(o))
            {
                return false;
            }
        }

        return true;
    }

    public void AddFilter(Predicate<object> filter)
    {
        _filters.Add(filter);
    }

    public void RemoveFilter(Predicate<object> filter)
    {
        if (_filters.Contains(filter))
        {
            _filters.Remove(filter);
        }
    }

    public void RemoveAllFilters()
    {
        _filters.Clear();
    }
}

The issue is when the property the user wants to filter by is an enum. I can easily use a converter to populate the combo box with the enum's description attributes:

public class EnumDescriptionConverter : IValueConverter
{
    private string GetEnumDescription(Enum enumObj)
    {
        if (enumObj is null) return String.Empty;
        if (Enum.IsDefined(enumObj.GetType(), enumObj) is false) return String.Empty;

        FieldInfo fieldInfo = enumObj.GetType().GetField(enumObj.ToString());

        object[] attribArray = fieldInfo.GetCustomAttributes(false);

        if (attribArray.Length == 0)
        {
            return enumObj.ToString();
        }
        else
        {
            DescriptionAttribute attrib = attribArray[0] as DescriptionAttribute;
            return attrib.Description;
        }
    }

    object IValueConverter.Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        Enum myEnum = (Enum)value;
        string description = GetEnumDescription(myEnum);
        return description;
    }
}

However, I'm having a hard time getting the Enum from a given description. I found https://stackoverflow.com/a/3422440/ which states I can use LINQ to iterate through Enum.GetValues(myEnum), but it requires passing the enum I want to evaluate, which the binding does not; as far as the converter knows, the target type it's trying to convert back to is just Enum.

I tried passing the list of enums used to populate the available values so ConvertBack could use it, but I was told bound data cannot be used as converter parameters. Is there a way I can do this? If not, are there other ways I could do it?

From what you're trying to achieve, you'd have an easier time just implementing OData instead of doing this in a roundabout way with Reflection. — Tiramonium, Sep 24 '21 at 15:54
Do you want a filter function/field specific for each property or could one for all work for you? — Tiramonium, Sep 24 '21 at 15:57
Ideally it'd be better to have a single method that filters the CollectionView given a property, a value and, optionally a parameter (for example, if the property is a string, the user might want to filter by "contains", "startswith" or "equals") — Artur S., Sep 24 '21 at 16:04
It's a facilitator for filtering, ordering and paginating on ASP.NET web applications which works by setting a out of the box default annotation on the Controllers, with the front-end telling the back-end what to filter, order or paginate through the QueryString — Tiramonium, Sep 24 '21 at 16:04
Seems like the proper way of filtering with a WPF CollectionView is through making a Delegate function or an Event Handler function and adding it to its Filter property. You can read about it on Microsoft's [page](https://learn.microsoft.com/pt-br/dotnet/desktop/wpf/data/how-to-filter-data-in-a-view?view=netframeworkdesktop-4.8) — Tiramonium, Sep 24 '21 at 16:09
Well, after the user selects a property/column and enters the data they want to filter by, I send that info to a function that appends the applied filter (the user's able to apply filter over another filter) and I set the view's filter with the newly created one. I'll add that part on the question. — Artur S., Sep 24 '21 at 16:13
You need two converters. The first will get the enum type and list its values. You pass this list to the views for selection by the user. Let's say ComboBox.ItemsSource. The second converter receives one of the enumeration values, and if it has an attribute to represent, it returns its string representation. If there is no attribute, then returns the string representation of the received enumeration value. This converter is already used in the representation of one item in a collection of values. — EldHasp, Sep 24 '21 at 16:41
As a result, the user will see a list of the enumeration attributes, but will actually select the enumeration value. And you can already easily use the value he chose. — EldHasp, Sep 24 '21 at 16:41

score 1 · Accepted Answer · answered Sep 24 '21 at 17:08

If the targetType parameter in IValueConverter.Convert is really only giving you Enum, rather than the specific type of enumeration you need to convert to, then I don't think converting from the Description value alone will be possible. Actually, it might not be reliable anyway, because nothing is stopping anyone from creating two different values in the same enumeration and giving them identical descriptions (thus resulting in ambiguity).

Here's my suggestion: Instead of returning a string return a custom struct. Something like this:

public struct EnumValue
{
    public EnumValue(Enum value, string description)
    {
        Value = value;
        Description = description;
    }

    public Enum Value { get; }
    public string Description { get; }

    public override string ToString()
    {
        return Description;
    }
}

Returning something like the above instead of just the description string value, will allow you to convert back to the enumeration value just by reading the Value property.

(You could also go a step further and put the actual logic for retrieving the description into the EnumValue struct, removing the description parameter from the constructor.)

Can I get an enum value having a given description attribute using a generic function?

1 Answers1