Curiously Recurring Template Pattern (CRTP) in C#

[zpbappi]

Auto-generated issue to track comments for the post Curiously Recurring Template Pattern (CRTP) in C# in my blog.

[TomasJuocepis]

Great post! I've "re-invented" this pattern as well when I was writing an Enumeration class in C#. I discovered that this is a well known pattern with a name when I was almost done with my Enumeration class but wanted to resolve a few tricky issues and was searching for answers and came across Eric Lippert's post Curiouser and Curiuoser (https://blogs.msdn.microsoft.com/ericlippert/2011/02/03/curiouser-and-curiouser/). I come from Java background and the thing I miss the most is Java-like enumerations. When I need a proper OO enumeration type I typically just create a class without public constructors and expose enumerated instances as static fields. This is ok for many basic use cases, but it gets annoying to re-implement every common enumeration feature in each enumeration class. I recently found that there is a github project for Enumeration class in C# already which is very similar to what I've done on my own. In hindsight, I should've searched first instead of jumping to roll my own solutions, but it was a fun learning experience nevertheless.
One interesting tidbit I'd like to add - there is one "issue" I found with this pattern - Imposter/hijacker classes. It's perfectly legal to create derived classes that pretend to be other derived classes:

public class RealDeal : Base<RealDeal> { ... }
// malicious subverter using your library
public class Fake : Base<RealDeal> { ... }

In my enumeration case, it was possible to mess up existing enumerations, so I had to insert some type checking code for detection of this scenario so that there was no chance for one derived class to affect another.

Also, I'll take your suggestion to use TDerived. I've been using TSelf, but I think TDerived is a bit more clear.

[zpbappi]

@TomasJuocepis yeah, it feels good to re-invent the wheel. in that case, you will know how the wheel rotates, better than most wheel users. :)
however, i could not quite catch the reason why you had to implement your own Enumerable class. could you point me to your repository if it is public? i will get a better understanding then.

about the Fake : Base<RealDeal> usage, it is an interesting use-case. however, i don't think it can qualify as a hijacker. because, when you are asking for a RealDeal instance in a method or ctor, you can only get an instance of RealDeal class or a class derived from it- not an instance of the Fake class. because Fake does not derive from RealDeal. however, if in a method, you are asking for a Base<RealDeal> instance and the behavior of this method is different depending on whether you pass RealDeal or Fake instance, then we have a different problem. to me, it is a clear violation of LSP.

[GeeLaw]

In fact, CRTP in C# is more useful than it is in C++. For example, one might want to build a polynomial on a numeric type (or field type, generally).

In C++ this can be done with template <typename TField> struct Polynomial;, in which we use operators (+, -, *, /, etc.) as we would with double.

However, in C# you will have to use CRTP to enforce such operation if you don't want to use the “IComparer mode” (using another object to perform arithmetic operations). A working snippet is too long to be written in a comment. Should I elaborate, refer to this entry (it has a slightly different setting, not concrete to a polynomial).

[Kagisho]

Great post! I'm interested in seeing which other use-cases this pattern would apply to.

[reasonet]

Here's an example implementation of an Enumeration class using CRTP:

public abstract class Enumeration<T> : IComparable where T : Enumeration<T>
{
    public Enum Id { get; private set; }
    public string Name { get; private set; }

    protected Enumeration(Enum id, string name)
    {
        Id = id;
        Name = name;
    }

    public override string ToString() => Name;
    public static T GetValue(Enum id) => GetAll().First(x => x.Id == id);
    public static T GetValue(byte id) => GetAll().First(x => Convert.ToByte(x.Id) == id);
    public static T GetValue(string name) => GetAll().First(x => x.Name == name);
    public static string GetName(Enum id) => GetValue(id).Name;
    public static string GetName(byte id) => GetValue(id).Name;
    public static Enum GetId(string name) => GetValue(name).Id;

    public static IEnumerable<SelectListItem> GetAsSelectListItems()
    {
        return GetAll().Select(x => new SelectListItem { Value = x.Id.ToString("d"), Text = x.Name });
    }

    public static IEnumerable<T> GetAll()
    {
        return typeof(T).GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly)
            .Select(f => f.GetValue(null))
            .Cast<T>();
    }

    // User-defined type conversion operator that must be invoked with a cast
    public static explicit operator Enum(Enumeration<T> enumeration) => enumeration.Id;
    public static explicit operator Enumeration<T>(Enum id) => GetValue(id);

    public override bool Equals(object obj)
    {
        var otherValue = obj as Enumeration<T>;
        if (otherValue == null)
            return false;

        var typeMatches = GetType().Equals(obj.GetType());
        var valueMatches = Id.Equals(otherValue.Id);
        return typeMatches && valueMatches;
    }

    public override int GetHashCode() => Tuple.Create(Id, Name).GetHashCode();
    public int CompareTo(object other) => Id.CompareTo(((Enumeration<T>)other).Id);
}

// Here's an example usage
public enum DataTypeId { Unknown = 0, Raw, Settled, Filtered, CFE }
public sealed class DataTypes : Enumeration<DataTypes>
{
    public static readonly DataTypes Raw = new DataTypes(DataTypeId.Raw, "Raw");
    public static readonly DataTypes Settled = new DataTypes(DataTypeId.Settled, "Settled");
    public static readonly DataTypes Filtered = new DataTypes(DataTypeId.Filtered, "Filtered");
    public static readonly DataTypes CFE = new DataTypes(DataTypeId.CFE, "CFE");

    private DataTypes(Enum id, string name) : base(id, name) { }
}