这个C＃构造的作用是什么？为什么？ 我的课 <TMyClass> ：MyClass在哪里

Question

I came across the following code, all in a single file/class. I'm leaving out the details, its the construct I'm interested in. Why are there two different declarations for the same class and how are they different? What's the purpose of the syntax for the second declaration?

public abstract class MyClass
{
    ...
}

public abstract class MyClass<TMyClass> : MyClass
    where TMyClass: MyClass<TMyClass>
{
    ...
}

Answer 1

MyClass - A abstract class named MyClass.

MyClass<TMyClass> : MyClass - A abstract generic class named MyClass<> but with a generic type named TMyClass .

If you rename the types, it will be easier to see:

public abstract class MyBaseClass
{
    ...
}

public abstract class MyClass<T> : MyBaseClass
    where T: MyClass<T>
{
    ...
}

Answer 2

Types with different generic arity (ie number of generic type parameters, which can be zero or more) are considered as completely unrelated by the language and can have the same name.

This means that you can have classes Foo , Foo<T> and Foo<T,U> at the same time; the syntax will allow the compiler to determine which you are referring to. You can see this happen in the base framework which includes Action , Action<T> etc.

The "recursive" construct class C<T> where T: C<T> (the inheritance from a non-generic C does not change anything so I removed it) is the C# on what is called the Curiously Recurring Template Pattern (CRTP) in C++. Eric Lippert has covered this subject very well in a blog post, where the conclusion is that one should think more than twice before implementing this -- there are problems it can solve, but the solution also has a price.

Answer 3

public abstract class MyClass<TMyClass> : MyClass
    where TMyClass: MyClass<TMyClass>
{
    ...
}

is a class that inherits from MyClass , and it takes a generic type, which has to inherit from MyClass<TMyClass>

---

Here's a simpler example of the same thing for you

    public static void Main()
    {
        MyClass<Myclass> other = new MyClass<Myclass>(new Myclass());
        List<int> intlist = new List<int>();
    }

    public class Myclass
    {
        public Myclass()
        {
        }
        public int i { get; set; }
    }

    public class MyClass<T> where T : Myclass
    {
        T value;
        public MyClass(T val)
        {
            value = val;
        }
    }
}

Answer 4

It's a classic idiom, the Curiously Recurring Template Pattern, done in C#.

It means the template can only be used thusly:

class Foo : MyClass<Foo>
{
}

In this construction, Foo inherits MyClass<Foo> which inherits MyClass .

This has a few advantages, but I've forgotten which.

Answer 5

 public abstract class MyClass<TMyClass> : MyClass
       where TMyClass: MyClass<TMyClass>
 {
        ...
 }

First thing to point out is that this is an abstract class that is inheriting from another abstract class. In other words, this is a class that cannot be instantiated (without another class inheriting from it), but is using inheritence to derive the functionality from another abstract class (which is fine).

The second thing to point out, is that this is a Template class (or generic class as they call it in C#) which accepts type in it's . I would reduce that to T as a convention so that T is always a template, though it is completely up to you what you call things.

Lastly there is a constraint on this which is kind of strange. It says that, no matter what, the compiler will not allow any class type to be passed in as a template type, unless it inherits from (somewhere along the inheritance chain)

 MyClass<TMyClass>

This is shown in the following line

 where TMyClass: MyClass<TMyClass>

basically this prevents anyone from passing in an object that does not follow this rule.

What is a bit odd is that the constraints tells the implementer that it cannot be a template unless the type passed by template is in fact a type of itself. You as the designer of this class (or implementer) has to decide if this is a wise design, though this in itself looks a bit strange.