Language feature envy

Pedro Santos · 06 May 2016

In my day job I mainly write C# code. On my own I like to try other languages like Swift, F#, Clojure, Objective C or Java. I learn a lot from writing code in different languages. When I go back to C# I often miss some of the features C# does not have. By far what I miss the most is Java/Swift enums. It happens quite frequently that I need to express a few finite number of instances of a type. The Java planets example illustrates this quite effectively.

Recently I was porting a music library I wrote in Swift Ellis to C#. In music there are only 12 notes so using a class to express a musical note feels wrong. Using a enum in C# would be the correct choice... If I could only add behaviour to enums in C#. Here is an excerpt of the Note enum in Swift:

public enum Note: Int
    case C = 0
    case CSharp
    case DFlat
    case D
    case DSharp
    case EFlat

    public func sharp() -> Note

    public func flat() -> Note

    public func intervalWithNote(other: Note) -> Interval

    public func measureAbsoluteSemitones(other: Note) -> Int

    public func transpose(transposingInterval: Interval) -> Note

Note that besides being able to define a finite number of instances I'm also able to add behaviour to my enum.

In C# we are stuck with using something like:

public class Note
    public static readonly Note C = new Note(Pitch.C, "C", Accident.None, MinNoteIndex);
    public static readonly Note CSharp = new Note(Pitch.CSharp, "C#", Accident.Sharp, 1);
    public static readonly Note DFlat = new Note(Pitch.DFlat, "Db", Accident.Flat, 2);
    public static readonly Note D = new Note(Pitch.D, "D", Accident.None, 3);
    public static readonly Note DSharp = new Note(Pitch.DSharp, "D#", Accident.Sharp, 4);
    public static readonly Note EFlat = new Note(Pitch.EFlat, "Eb", Accident.Flat, 5);
    public static readonly Note E = Note(Pitch.E, "E", Accident.None, 6);
    public static readonly Note F = new Note(Pitch.F, "F", Accident.None, 7);
    public static readonly Note FSharp = new Note(Pitch.FSharp, "F#", Accident.Sharp, 8);

    private Note(Pitch pitch, string name, Accident accident, int index)

It's not too bad, but not exactly the same as in Java or Swift.

There is a feature in Java enums that I still miss for my note implementation in C#, the ordinal method:

public final int ordinal()

This according to the Java documentation "Returns the ordinal of this enumeration constant (its position in its enum declaration, where the initial constant is assigned an ordinal of zero)".

If I want to emulate this behaviour in C# I can do something like:

public static IEnumerable<Note> Notes
        yield return C;
        yield return CSharp;
        yield return DFlat;
        yield return D;
        yield return DSharp;
        yield return EFlat;
        yield return E;
        yield return F;
        yield return FSharp;

Now I can access Note instances using an indexer with code like this:


Again not ideal but not terrible either. But notice that we are adding up workarounds, all small but it adds up. If you want to look at the complete implementation it’s on my GitHub Jaco.Notes.Note


Why don't you create a proposal to have this implemented in C#?

Nothing is ever original, others have explored that route already.

Jon Skeet blogged about this in 2006:

There are a couple of discussions on Roslyn GitHub:

The only problem is this patent may prevent other languages from having the same behaviour Java has on enums:

Codurance Logo

Software es nuestra pasión.

Somos Software Craftspeople. Construimos software bien elaborado para nuestros clientes, ayudamos a los desarrolladores a mejorar en su oficio a través de la formación, la orientación y la tutoría y ayudamos a las empresas a mejorar en la distribución de software.

Últimos Blogs


15 Northburgh Street
London EC1V 0JR

Teléfono: +44 207 4902967

Carrer Aragó, 208
08011, Barcelona

Teléfono: +34 937 82 28 82

Correo electrónico: