How to create a c# enumeration with more than one property

Question

I want to create an enumeration like object but with an additional "property".

For example I could have a day of the week enumeration:

enum Day {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

Now, let's say I have another property I want to store against each day. Something that never changes. For the sake of the argument let's say we have a pay rate which never changes and is 1.5 on Saturday, 2 on Sunday and 1 otherwise.

Can't do this with enumeration. I was thinking of creating a "helper" static class that would just return this second property, but this seems clunky.

static class Rate
{
    static float GetRate(Day d)
    {
        switch (d)
        {
            case Day.Saturday:
                return 1.5f;
            case Day.Sunday:
                return 2f;
            default:
                return 1f;

        }
    }
}

Instead of enum with helper class I could use a ReadOnlyCollection but that seems complicated and heavy-weight for what I need.

What is the best way to go here?

You need some key-value-pair-logic, for example a List of `KeyValuePair`, or essentially a `Dictionary`. You could also create your own class for this or as you already did a method returning the property for a given enum-value. — MakePeaceGreatAgain, Dec 16 '16 at 09:29
I'm with @TaW. Just make the current method an extension method, so you can use it more naturally. — Ivan Stoev, Dec 16 '16 at 09:30
If it works but you are not sure if it's the proper way to do it, you should ask on [Code Review](http://codereview.stackexchange.com/) instead. Opinion based questions are off-topic here. — Manfred Radlwimmer, Dec 16 '16 at 09:36

score 3 · Accepted Answer · answered Dec 16 '16 at 09:31

C# enum values are simple single-values unlike in other languages where they can be complex-types (e.g. tuples).

If the enum value represents a "key" for immutable data, you could hack it by using an extension method with a switch block - similar to your example, but syntactically cleaner when used:

enum Day {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

public static class DayExtensions
{
    public static Single GetRate(this Day d)
    {
        switch( d )
        {
            case Day.Saturday:
                return 1.5f;
            case Day.Sunday:
                return 2f;
            default:
                return 1f;
        }
    }
}

Usage:

Day d = Day.Monday;
Single rate = d.GetRate();

This is in fact a very common way to extend enum functionality. You keep the extension class in the same source code file as the enum, because they are logically part of the same type. — Matthew Watson, Dec 16 '16 at 09:33

score 2 · Answer 2 · answered Dec 16 '16 at 09:29

What you can do is add a custom attribute to the enum values like so:

enum Day {
    [MyAttr(Rate=1.5f)]
    Sunday, 
    [MyAttr(Rate=2)]
    Monday
}

public class MyAttr : Attribute {
    public float Rate {get;set;}
}

Then read the attribute like this:

public float GetRate(Day day) {
    MemberInfo memberInfo = typeof(Day).GetMember(day.ToString()).FirstOrDefault();

    if (memberInfo != null) {
        MyAttr attribute = (MyAttr)memberInfo
            .GetCustomAttributes(typeof(MyAttr), false)
            .FirstOrDefault();
        return attribute.Rate;
    }

    return 0;
}

Marc Gravell · Answer 3 · 2016-12-16T09:32:35.310

1

Perhaps something like:

public struct Day
{
    public Day(int key, float rate)
    {
        _key = key;
        _rate = rate;
    }
    private readonly int _key;
    private readonly float _rate;
    public int Key => _key;
    public float Rate => _rate;

    public static readonly Day
        Monday = new Day(0, 1f),
        Tuesday = new Day(0, 1f), ...;

    public static implicit operator int(Day day) => day.Key;
}

Then Day.Monday.Rate works, and int day = Day.Monday works.

edited Dec 16 '16 at 09:32

answered Dec 16 '16 at 09:28

Marc Gravell

1,026,079
266
2,566
2,900

Why have both readonly private fields and public properties simultaneously? – Dai Dec 16 '16 at 09:29
@Dai feel free to adjust locally to suit etc :) – Marc Gravell Dec 16 '16 at 09:31
@Dai You cannot have a `readonly` property. The `readonly` keyword garantuees that the value of the field cannot be modified outside of the constructor. – Maarten Dec 16 '16 at 09:36
@Maarten C# 6.0 introduced true readonly properties using the `public PropertyName { get; }` syntax, which uses a `readonly` backing field. – Dai Dec 16 '16 at 09:55
@Dai I think you mean C# 6.0. – Maarten Dec 16 '16 at 09:57

Maarten · Answer 4 · 2016-12-16T09:37:34.860

You can use a sealed class with predefined static instances. The extra property (or properties) can be read either as property, or via implicit conversion.

public sealed class Day
{
    private Day(float rate)
    {
        m_Rate = rate;
    }

    private readonly float m_Rate;
    public float Rate { get { return m_Rate; } }

    public static readonly Day Saturday = new Day(1.5f);
    public static readonly Day Sunday = new Day(2f);
    public static readonly Day Monday = new Day(1f);
    public static readonly Day Tuesday = new Day(1f);
    public static readonly Day Wednesday = new Day(1f);
    public static readonly Day Thursday = new Day(1f);
    public static readonly Day Friday = new Day(1f);

    public static implicit operator float(Day day)
    {
        return day.m_Rate;
    }
}

Usage:

var day = Day.Sunday;
var rate = day.Rate;      // Use property
float rate2 = day;        // Use implicit conversion

How to create a c# enumeration with more than one property

4 Answers4