How this Generic Inheritance is done (internally) ?

Question

Hi, How do you think the following code? Is this good? If so, why it is? If not, why it is not? And how CLR see this code?

public abstract class EntityBase<TEntity> : IEquatable<TEntity>
{        
    public bool Equals(TEntity other)
    {
        // check equalitiy
    }

    // yes, below is object's Equals and GetHashCode method implementation
}

public class Person : EntityBase<Person>
{
}

I have a bit odd feeling on this. Like chicken and egg problem. And here is .Net framework code which has the same behaviour.

public sealed class String : IComparable<string>, IEquatable<string> // I removed other interfaces

Any thoughts?

Answer 1

In the right circumstances (e.g. implementing IComparable<T>) it is exactly the right thing to do.

But this can only be determined on a case by case basis, looking at the details of why it is being considered.

On the other hand, C++ allows the "curiously recurring base pattern":

template<typename T>
class SomeWrapper<T> : T { ... ]

where a generic class inherits its generic wrapper. This allows some advanced wrapping scenarios, but can rapidely become confusing if used beyond wrapping. Fortunately(?) this pattern is not allowed in .NET.

Answer 2

I don't see a problem with your code. Why would it be a problem?

About the internal representation, the dotNet JIT compiles a class for every generic version. So the following:

class Foo<T> { public T Property; }
Foo<Int> fooint;
Foo<String> foostring;

Is sort of compiled into:

class FooInt { public Int Property; } 
class FooString { public String Property; }
FooInt fooint;
FooString foostring;
// This is kept for if it is needed later.
// For example for generic casting, a C#4 feature.
class Foo<T> { public T Property; }

Answer 3

Not really an answer, but I found it sort of make sense after I wrote this weird code...

class Program
{
    static void Main(string[] args)
    {
        var wife = new Human(Gender.Female);
        var baby = wife.GiveBirth();
        Console.WriteLine(baby.Gender);

        Console.ReadKey();
    }
}

class CanGiveBirthTo<T> where T : new()
{
    public CanGiveBirthTo()
    {
    }

    public T GiveBirth()
    {
        return new T();
    }
}

class Human : CanGiveBirthTo<Human>
{
    public Gender Gender { get; private set; }

    public Human(Gender gender)
    {
        Gender = gender;
    }

    public Human()
    {
        Gender = RandomlyAssignAGender();
    }

    Gender RandomlyAssignAGender()
    {
        var rand = new Random();
        return (Gender) rand.Next(2);
    }
}

enum Gender
{
    Male = 0,
    Female = 1
}

Answer 4

For other people reference, I copied the answer of Eric Lippert (who answer in the comment).

Though the definition appears circular, it is not. However, the C# compilers cycle detection algorithm is both wrong and weak. Wrong because it incorrectly detects non-cycles as cycles, and weak because it fails to detect certain very nasty cycles. If this topic interests you, see my article on it here: http://blogs.msdn.com/ericlippert/archive/2008/05/07/covariance-and-contravariance-part-twelve-to-infinity-but-not-beyond.aspx